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

   1 /**\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2000-2009, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 package com.ibm.icu.dev.test.calendar;\r
   8 \r
   9 import java.io.ByteArrayInputStream;\r
  10 import java.io.ByteArrayOutputStream;\r
  11 import java.io.IOException;\r
  12 import java.io.ObjectInputStream;\r
  13 import java.io.ObjectOutput;\r
  14 import java.io.ObjectOutputStream;\r
  15 import java.util.Date;\r
  16 import java.util.Locale;\r
  17 \r
  18 import com.ibm.icu.text.DateFormat;\r
  19 import com.ibm.icu.util.Calendar;\r
  20 import com.ibm.icu.util.GregorianCalendar;\r
  21 import com.ibm.icu.util.SimpleTimeZone;\r
  22 import com.ibm.icu.util.TimeZone;\r
  23 \r
  24 public class CompatibilityTest extends com.ibm.icu.dev.test.TestFmwk {\r
  25 \r
  26     public static void main(String argv[]) throws Exception {\r
  27         new CompatibilityTest().run(argv);\r
  28     }\r
  29 \r
  30     static final String[] FIELD_NAME = {\r
  31         "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",\r
  32         "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",\r
  33         "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",\r
  34         "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",\r
  35         "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",\r
  36         "JULIAN_DAY", "MILLISECONDS_IN_DAY",\r
  37     };\r
  38 \r
  39     /**\r
  40      * Test the behavior of the GregorianCalendar around the changeover.\r
  41      */\r
  42     public void TestGregorianChangeover() {\r
  43     \r
  44         java.util.TimeZone jdkGMT = java.util.TimeZone.getTimeZone("GMT");\r
  45         java.util.Calendar jdkCal = java.util.Calendar.getInstance(jdkGMT);\r
  46         jdkCal.clear();\r
  47         jdkCal.set(1582, Calendar.OCTOBER, 15);\r
  48         \r
  49 //      if(jdkCal instanceof java.util.GregorianCalendar) {\r
  50 //          logln("jdk IS grego");\r
  51 //          java.util.GregorianCalendar jdkgc = (java.util.GregorianCalendar)\r
  52 //          jdkCal;\r
  53 //          logln("jdk change at: " + jdkgc.getGregorianChange() + "(" + jdkgc.getGregorianChange().getTime() +")" );\r
  54 //      } else {\r
  55 //          logln("jdk NOT grego");\r
  56 //      }\r
  57 \r
  58         long a = jdkCal.getTime().getTime();\r
  59         Date c = jdkCal.getTime();\r
  60         c.toString();\r
  61         long b = c.getTime();\r
  62         if(a!=b) {\r
  63             logln(" " + a + " != " + b);\r
  64             logln("JDK has Gregorian cutover anomaly (1.5?) - skipping this test.");\r
  65             return;\r
  66         }\r
  67 \r
  68         Date co = jdkCal.getTime();\r
  69         logln("Change over (Oct 15 1582) = " + co + " (" + co.getTime() + ")");\r
  70         final int ONE_DAY = 24*60*60*1000;\r
  71         TimeZone gmt = TimeZone.getTimeZone("GMT");\r
  72         GregorianCalendar cal = new GregorianCalendar(gmt);\r
  73         /*\r
  74           Changeover -7 days: 1582/9/28 dow=6\r
  75           Changeover -6 days: 1582/9/29 dow=7\r
  76           Changeover -5 days: 1582/9/30 dow=1\r
  77           Changeover -4 days: 1582/10/1 dow=2\r
  78           Changeover -3 days: 1582/10/2 dow=3\r
  79           Changeover -2 days: 1582/10/3 dow=4\r
  80           Changeover -1 days: 1582/10/4 dow=5\r
  81           Changeover +0 days: 1582/10/15 dow=6\r
  82           Changeover +1 days: 1582/10/16 dow=7\r
  83           Changeover +2 days: 1582/10/17 dow=1\r
  84           Changeover +3 days: 1582/10/18 dow=2\r
  85           Changeover +4 days: 1582/10/19 dow=3\r
  86           Changeover +5 days: 1582/10/20 dow=4\r
  87           Changeover +6 days: 1582/10/21 dow=5\r
  88           Changeover +7 days: 1582/10/22 dow=6\r
  89           */\r
  90         int MON[] = {  9,  9,  9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };\r
  91         int DOM[] = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };\r
  92         int DOW[] = {  6,  7,  1, 2, 3, 4, 5,  6,  7,  1,  2,  3,  4,  5,  6 };\r
  93         //                                     ^ <-Changeover Fri Oct 15 1582\r
  94         int j=0;\r
  95         for (int i=-7; i<=7; ++i, ++j) {\r
  96             Date d = new Date(co.getTime() + i*ONE_DAY);\r
  97             cal.setTime(d);\r
  98             int y = cal.get(Calendar.YEAR), mon = cal.get(Calendar.MONTH)+1-Calendar.JANUARY,\r
  99                 dom = cal.get(Calendar.DATE), dow = cal.get(Calendar.DAY_OF_WEEK);\r
 100             logln("Changeover " + (i>=0?"+":"") +\r
 101                   i + " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);\r
 102             if (y != 1582 || mon != MON[j] || dom != DOM[j] || dow != DOW[j])\r
 103                 errln(" Fail: Above line is wrong");\r
 104         }\r
 105     }\r
 106 \r
 107     /**\r
 108      * Test the mapping between millis and fields.  For the purposes\r
 109      * of this test, we don't care about timezones and week data\r
 110      * (first day of week, minimal days in first week).\r
 111      */\r
 112     public void TestMapping() {\r
 113         if (false) {\r
 114             Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);\r
 115             Date PURE_JULIAN = new Date(Long.MAX_VALUE);\r
 116             GregorianCalendar cal =\r
 117                 new GregorianCalendar(TimeZone.getTimeZone("UTC"));\r
 118             final int EPOCH_JULIAN = 2440588;\r
 119             final long ONE_DAY = 24*60*60*1000L;\r
 120             com.ibm.icu.text.SimpleDateFormat fmt =\r
 121                 new com.ibm.icu.text.SimpleDateFormat("EEE MMM dd yyyy G");\r
 122                 /*HH:mm:ss.SSS z*/\r
 123 \r
 124             for (int type=0; type<2; ++type) {\r
 125                 System.out.println(type==0 ? "Gregorian" : "Julian");\r
 126                 cal.setGregorianChange(type==0 ? PURE_GREGORIAN : PURE_JULIAN);\r
 127                 fmt.setCalendar(cal);\r
 128                 int[] J = {\r
 129                     0x7FFFFFFF,\r
 130                     0x7FFFFFF0,\r
 131                     0x7F000000,\r
 132                     0x78000000,\r
 133                     0x70000000,\r
 134                     0x60000000,\r
 135                     0x50000000,\r
 136                     0x40000000,\r
 137                     0x30000000,\r
 138                     0x20000000,\r
 139                     0x10000000,\r
 140                 };\r
 141                 for (int i=0; i<J.length; ++i) {\r
 142                     String[] lim = new String[2];\r
 143                     long[] ms = new long[2];\r
 144                     int jd = J[i];\r
 145                     for (int sign=0; sign<2; ++sign) {\r
 146                         int julian = jd;\r
 147                         if (sign==0) julian = -julian;\r
 148                         long millis = ((long)julian - EPOCH_JULIAN) * ONE_DAY;\r
 149                         ms[sign] = millis;\r
 150                         cal.setTime(new Date(millis));\r
 151                         lim[sign] = fmt.format(cal.getTime());\r
 152                     }\r
 153                     System.out.println("JD +/-" +\r
 154                                        Long.toString(jd, 16) +\r
 155                                        ": " + ms[0] + ".." + ms[1] +\r
 156                                        ": " + lim[0] + ".." + lim[1]);\r
 157                 }\r
 158             }\r
 159         }\r
 160 \r
 161         TimeZone saveZone = TimeZone.getDefault();\r
 162         try {\r
 163             TimeZone.setDefault(TimeZone.getTimeZone("UTC"));\r
 164             //NEWCAL\r
 165             Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);\r
 166             Date PURE_JULIAN = new Date(Long.MAX_VALUE);\r
 167             GregorianCalendar cal = new GregorianCalendar();\r
 168             final int EPOCH_JULIAN = 2440588;\r
 169             final long ONE_DAY = 24*60*60*1000L;\r
 170             int[] DATA = {\r
 171                 // Julian#   Year  Month               DOM   JULIAN:Year, Month,       DOM\r
 172                 2440588,     1970, Calendar.JANUARY,   1,    1969, Calendar.DECEMBER,  19, \r
 173                 2415080,     1900, Calendar.MARCH,     1,    1900, Calendar.FEBRUARY,  17,\r
 174                 2451604,     2000, Calendar.FEBRUARY,  29,   2000, Calendar.FEBRUARY,  16,\r
 175                 2452269,     2001, Calendar.DECEMBER,  25,   2001, Calendar.DECEMBER,  12,\r
 176                 2416526,     1904, Calendar.FEBRUARY,  15,   1904, Calendar.FEBRUARY,  2,\r
 177                 2416656,     1904, Calendar.JUNE,      24,   1904, Calendar.JUNE,      11,\r
 178                 1721426,        1, Calendar.JANUARY,   1,       1, Calendar.JANUARY,   3,\r
 179                 2000000,      763, Calendar.SEPTEMBER, 18,    763, Calendar.SEPTEMBER, 14,\r
 180                 4000000,     6239, Calendar.JULY,      12,   6239, Calendar.MAY,       28,\r
 181                 8000000,    17191, Calendar.FEBRUARY,  26,  17190, Calendar.OCTOBER,   22,\r
 182                 10000000,   22666, Calendar.DECEMBER,  20,  22666, Calendar.JULY,      5,\r
 183             };\r
 184             for (int i=0; i<DATA.length; i+=7) {\r
 185                 int julian = DATA[i];\r
 186                 int year = DATA[i+1];\r
 187                 int month = DATA[i+2];\r
 188                 int dom = DATA[i+3];\r
 189                 int year2, month2, dom2;\r
 190                 long millis = (julian - EPOCH_JULIAN) * ONE_DAY;\r
 191                 String s;\r
 192 \r
 193                 // Test Gregorian computation\r
 194                 cal.setGregorianChange(PURE_GREGORIAN);\r
 195                 cal.clear();\r
 196                 cal.set(year, month, dom);\r
 197                 long calMillis = cal.getTime().getTime();\r
 198                 long delta = calMillis - millis;\r
 199                 cal.setTime(new Date(millis));\r
 200                 year2 = cal.get(Calendar.YEAR);\r
 201                 month2 = cal.get(Calendar.MONTH);\r
 202                 dom2 = cal.get(Calendar.DAY_OF_MONTH);\r
 203                 s = "G " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +\r
 204                     " => " + calMillis +\r
 205                     " (" + ((float)delta/ONE_DAY) + " day delta) => " +\r
 206                     year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;\r
 207                 if (delta != 0 || year != year2 || month != month2 ||\r
 208                     dom != dom2) errln(s + " FAIL");\r
 209                 else logln(s);\r
 210                 \r
 211                 // Test Julian computation\r
 212                 year = DATA[i+4];\r
 213                 month = DATA[i+5];\r
 214                 dom = DATA[i+6];\r
 215                 cal.setGregorianChange(PURE_JULIAN);\r
 216                 cal.clear();\r
 217                 cal.set(year, month, dom);\r
 218                 calMillis = cal.getTime().getTime();\r
 219                 delta = calMillis - millis;\r
 220                 cal.setTime(new Date(millis));\r
 221                 year2 = cal.get(Calendar.YEAR);\r
 222                 month2 = cal.get(Calendar.MONTH);\r
 223                 dom2 = cal.get(Calendar.DAY_OF_MONTH);\r
 224                 s = "J " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +\r
 225                     " => " + calMillis +\r
 226                     " (" + ((float)delta/ONE_DAY) + " day delta) => " +\r
 227                     year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;\r
 228                 if (delta != 0 || year != year2 || month != month2 ||\r
 229                     dom != dom2) errln(s + " FAIL");\r
 230                 else logln(s);\r
 231             }\r
 232 \r
 233             java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 234             tempcal.clear();\r
 235             tempcal.set(1582, Calendar.OCTOBER, 15);\r
 236             cal.setGregorianChange(tempcal.getTime());\r
 237             auxMapping(cal, 1582, Calendar.OCTOBER, 4);\r
 238             auxMapping(cal, 1582, Calendar.OCTOBER, 15);\r
 239             auxMapping(cal, 1582, Calendar.OCTOBER, 16);\r
 240             for (int y=800; y<3000; y+=1+(int)(100*Math.random())) {\r
 241                 for (int m=Calendar.JANUARY; m<=Calendar.DECEMBER; ++m) {\r
 242                     auxMapping(cal, y, m, 15);\r
 243                 }\r
 244             }\r
 245         }\r
 246         finally {\r
 247             TimeZone.setDefault(saveZone);\r
 248         }\r
 249     }\r
 250     private void auxMapping(Calendar cal, int y, int m, int d) {\r
 251         cal.clear();\r
 252         cal.set(y, m, d);\r
 253         long millis = cal.getTime().getTime();\r
 254         cal.setTime(new Date(millis));\r
 255         int year2 = cal.get(Calendar.YEAR);\r
 256         int month2 = cal.get(Calendar.MONTH);\r
 257         int dom2 = cal.get(Calendar.DAY_OF_MONTH);\r
 258         if (y != year2 || m != month2 || dom2 != d)\r
 259             errln("Round-trip failure: " + y + "-" + (m+1) + "-"+d+" =>ms=> " +\r
 260                   year2 + "-" + (month2+1) + "-" + dom2);\r
 261     }\r
 262 \r
 263     public void TestGenericAPI() {\r
 264         // not used String str;\r
 265 \r
 266         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 267         tempcal.clear();\r
 268         tempcal.set(1990, Calendar.APRIL, 15);\r
 269         Date when = tempcal.getTime();\r
 270 \r
 271         String tzid = "TestZone";\r
 272         int tzoffset = 123400;\r
 273 \r
 274         SimpleTimeZone zone = new SimpleTimeZone(tzoffset, tzid);\r
 275         Calendar cal = (Calendar)Calendar.getInstance((SimpleTimeZone)zone.clone());\r
 276 \r
 277         if (!zone.equals(cal.getTimeZone())) errln("FAIL: Calendar.getTimeZone failed");\r
 278 \r
 279         Calendar cal2 = Calendar.getInstance(cal.getTimeZone());\r
 280 \r
 281         cal.setTime(when);\r
 282         cal2.setTime(when);\r
 283 \r
 284         if (!(cal.equals(cal2))) errln("FAIL: Calendar.operator== failed");\r
 285         // if ((*cal != *cal2))  errln("FAIL: Calendar.operator!= failed");\r
 286         if (!cal.equals(cal2) ||\r
 287             cal.before(cal2) ||\r
 288             cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
 289 \r
 290         cal2.setTime(new Date(when.getTime() + 1000));\r
 291         if (cal.equals(cal2) ||\r
 292             cal2.before(cal) ||\r
 293             cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
 294 \r
 295         cal.roll(Calendar.SECOND, true);\r
 296         if (!cal.equals(cal2) ||\r
 297             cal.before(cal2) ||\r
 298             cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
 299 \r
 300         // Roll back to January\r
 301         cal.roll(Calendar.MONTH, (int)(1 + Calendar.DECEMBER - cal.get(Calendar.MONTH)));\r
 302         if (cal.equals(cal2) ||\r
 303             cal2.before(cal) ||\r
 304             cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
 305 \r
 306         // C++ only\r
 307         /* TimeZone z = cal.orphanTimeZone();\r
 308            if (z.getID(str) != tzid ||\r
 309            z.getRawOffset() != tzoffset)\r
 310            errln("FAIL: orphanTimeZone failed");\r
 311            */\r
 312 \r
 313         for (int i=0; i<2; ++i) {\r
 314             boolean lenient = ( i > 0 );\r
 315             cal.setLenient(lenient);\r
 316             if (lenient != cal.isLenient()) errln("FAIL: setLenient/isLenient failed");\r
 317             // Later: Check for lenient behavior\r
 318         }\r
 319 \r
 320         int i;\r
 321         for (i=Calendar.SUNDAY; i<=Calendar.SATURDAY; ++i) {\r
 322             cal.setFirstDayOfWeek(i);\r
 323             if (cal.getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");\r
 324         }\r
 325 \r
 326         for (i=1; i<=7; ++i) {\r
 327             cal.setMinimalDaysInFirstWeek(i);\r
 328             if (cal.getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");\r
 329         }\r
 330 \r
 331         for (i=0; i<cal.getFieldCount(); ++i) {\r
 332             if (cal.getMinimum(i) > cal.getGreatestMinimum(i))\r
 333                 errln("FAIL: getMinimum larger than getGreatestMinimum for field " + i);\r
 334             if (cal.getLeastMaximum(i) > cal.getMaximum(i))\r
 335                 errln("FAIL: getLeastMaximum larger than getMaximum for field " + i);\r
 336             if (cal.getMinimum(i) >= cal.getMaximum(i))\r
 337                 errln("FAIL: getMinimum not less than getMaximum for field " + i);\r
 338         }\r
 339 \r
 340         cal.setTimeZone(TimeZone.getDefault());\r
 341         cal.clear();\r
 342         cal.set(1984, 5, 24);\r
 343         tempcal.clear();\r
 344         tempcal.set(1984, 5, 24);\r
 345         if (cal.getTime().getTime() != tempcal.getTime().getTime()) {\r
 346             errln("FAIL: Calendar.set(3 args) failed");\r
 347             logln(" Got: " + cal.getTime() + "  Expected: " + tempcal.getTime());\r
 348         }\r
 349 \r
 350         cal.clear();\r
 351         cal.set(1985, 2, 2, 11, 49);\r
 352         tempcal.clear();\r
 353         tempcal.set(1985, 2, 2, 11, 49);\r
 354         if (cal.getTime().getTime() != tempcal.getTime().getTime()) {\r
 355             errln("FAIL: Calendar.set(5 args) failed");\r
 356             logln(" Got: " + cal.getTime() + "  Expected: " + tempcal.getTime());\r
 357         }\r
 358 \r
 359         cal.clear();\r
 360         cal.set(1995, 9, 12, 1, 39, 55);\r
 361         tempcal.clear();\r
 362         tempcal.set(1995, 9, 12, 1, 39, 55);\r
 363         if (cal.getTime().getTime() != tempcal.getTime().getTime()) {\r
 364             errln("FAIL: Calendar.set(6 args) failed");\r
 365             logln(" Got: " + cal.getTime() + "  Expected: " + tempcal.getTime());\r
 366         }\r
 367 \r
 368         cal.getTime();\r
 369         // This test is strange -- why do we expect certain fields to be set, and\r
 370         // others not to be?  Revisit the appropriateness of this.  - Alan NEWCAL\r
 371         for (i=0; i<cal.getFieldCount(); ++i) {\r
 372             switch(i) {\r
 373             case Calendar.YEAR: case Calendar.MONTH: case Calendar.DATE:\r
 374             case Calendar.HOUR_OF_DAY: case Calendar.MINUTE: case Calendar.SECOND:\r
 375             case Calendar.EXTENDED_YEAR:\r
 376                 if (!cal.isSet(i)) errln("FAIL: " + FIELD_NAME[i] + " is not set");\r
 377                 break;\r
 378             default:\r
 379                 if (cal.isSet(i)) errln("FAIL: " + FIELD_NAME[i] + " is set");\r
 380             }\r
 381             cal.clear(i);\r
 382             if (cal.isSet(i)) errln("FAIL: Calendar.clear/isSet failed");\r
 383         }\r
 384 \r
 385         // delete cal;\r
 386         // delete cal2;\r
 387 \r
 388         Locale[] loc = Calendar.getAvailableLocales();\r
 389         long count = loc.length;\r
 390         if (count < 1 || loc == null) {\r
 391             errln("FAIL: getAvailableLocales failed");\r
 392         }\r
 393         else {\r
 394             for (i=0; i<count; ++i) {\r
 395                 cal = Calendar.getInstance(loc[i]);\r
 396                 // delete cal;\r
 397             }\r
 398         }\r
 399 \r
 400         cal = Calendar.getInstance(TimeZone.getDefault(), Locale.ENGLISH);\r
 401         // delete cal;\r
 402 \r
 403         cal = Calendar.getInstance(zone, Locale.ENGLISH);\r
 404         // delete cal;\r
 405 \r
 406         GregorianCalendar gc = new GregorianCalendar(zone);\r
 407         // delete gc;\r
 408 \r
 409         gc = new GregorianCalendar(Locale.ENGLISH);\r
 410         // delete gc;\r
 411 \r
 412         gc = new GregorianCalendar(Locale.ENGLISH);\r
 413         // delete gc;\r
 414 \r
 415         gc = new GregorianCalendar(zone, Locale.ENGLISH);\r
 416         // delete gc;\r
 417 \r
 418         gc = new GregorianCalendar(zone);\r
 419         // delete gc;\r
 420 \r
 421         gc = new GregorianCalendar(1998, 10, 14, 21, 43);\r
 422         tempcal.clear();\r
 423         tempcal.set(1998, 10, 14, 21, 43);\r
 424         if (gc.getTime().getTime() != tempcal.getTime().getTime())\r
 425             errln("FAIL: new GregorianCalendar(ymdhm) failed");\r
 426         // delete gc;\r
 427 \r
 428         gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55);\r
 429         tempcal.clear();\r
 430         tempcal.set(1998, 10, 14, 21, 43, 55);\r
 431         if (gc.getTime().getTime() != tempcal.getTime().getTime())\r
 432             errln("FAIL: new GregorianCalendar(ymdhms) failed");\r
 433 \r
 434         // C++ only:\r
 435         // GregorianCalendar gc2 = new GregorianCalendar(Locale.ENGLISH);\r
 436         // gc2 = gc;\r
 437         // if (gc2 != gc || !(gc2 == gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");\r
 438         // delete gc;\r
 439         // delete z;\r
 440     }\r
 441 \r
 442     // Verify Roger Webster's bug\r
 443     public void TestRog() {\r
 444         GregorianCalendar gc = new GregorianCalendar();\r
 445 \r
 446         int year = 1997, month = Calendar.APRIL, date = 1;\r
 447         gc.set(year, month, date); // April 1, 1997\r
 448 \r
 449         gc.set(Calendar.HOUR_OF_DAY, 23);\r
 450         gc.set(Calendar.MINUTE, 0);\r
 451         gc.set(Calendar.SECOND, 0);\r
 452         gc.set(Calendar.MILLISECOND, 0);\r
 453 \r
 454         for (int i = 0; i < 9; i++, gc.add(Calendar.DATE, 1)) {\r
 455             if (gc.get(Calendar.YEAR) != year ||\r
 456                 gc.get(Calendar.MONTH) != month ||\r
 457                 gc.get(Calendar.DATE) != (date + i))\r
 458                 errln("FAIL: Date " + gc.getTime() + " wrong");\r
 459         }\r
 460     }\r
 461 \r
 462     // Verify DAY_OF_WEEK\r
 463     public void TestDOW943() {\r
 464         dowTest(false);\r
 465         dowTest(true);\r
 466     }\r
 467 \r
 468     void dowTest(boolean lenient) {\r
 469         GregorianCalendar cal = new GregorianCalendar();\r
 470         cal.set(1997, Calendar.AUGUST, 12); // Wednesday\r
 471         cal.getTime(); // Force update\r
 472         cal.setLenient(lenient);\r
 473         cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1, 1996\r
 474         int dow = cal.get(Calendar.DAY_OF_WEEK);\r
 475         int min = cal.getMinimum(Calendar.DAY_OF_WEEK);\r
 476         int max = cal.getMaximum(Calendar.DAY_OF_WEEK);\r
 477         if (dow < min || dow > max) errln("FAIL: Day of week " + dow + " out of range");\r
 478         if (dow != Calendar.SUNDAY) {\r
 479             errln("FAIL2: Day of week should be SUNDAY; is " + dow + ": " + cal.getTime());\r
 480         }\r
 481         if (min != Calendar.SUNDAY || max != Calendar.SATURDAY) errln("FAIL: Min/max bad");\r
 482     }\r
 483 \r
 484     // Verify that the clone method produces distinct objects with no\r
 485     // unintentionally shared fields.\r
 486     public void TestClonesUnique908() {\r
 487         Calendar c = Calendar.getInstance();\r
 488         Calendar d = (Calendar)c.clone();\r
 489         c.set(Calendar.MILLISECOND, 123);\r
 490         d.set(Calendar.MILLISECOND, 456);\r
 491         if (c.get(Calendar.MILLISECOND) != 123 ||\r
 492             d.get(Calendar.MILLISECOND) != 456) {\r
 493             errln("FAIL: Clones share fields");\r
 494         }\r
 495     }\r
 496 \r
 497     // Verify effect of Gregorian cutoff value\r
 498     public void TestGregorianChange768() {\r
 499         boolean b;\r
 500         GregorianCalendar c = new GregorianCalendar();\r
 501         logln("With cutoff " + c.getGregorianChange());\r
 502         logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));\r
 503         logln(" (should be FALSE)");\r
 504         if (b != false) errln("FAIL");\r
 505         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 506         tempcal.clear();\r
 507         tempcal.set(1900, 0, 1);\r
 508         c.setGregorianChange(tempcal.getTime()); // Jan 1 1900\r
 509         logln("With cutoff " + c.getGregorianChange());\r
 510         logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));\r
 511         logln(" (should be TRUE)");\r
 512         if (b != true) errln("FAIL");\r
 513     }\r
 514 \r
 515     // Test the correct behavior of the disambiguation algorithm.\r
 516     public void TestDisambiguation765() throws Exception {\r
 517         Calendar c = Calendar.getInstance();\r
 518         c.setLenient(false);\r
 519 \r
 520         c.clear();\r
 521         c.set(Calendar.YEAR, 1997);\r
 522         c.set(Calendar.MONTH, Calendar.JUNE);\r
 523         c.set(Calendar.DATE, 3);\r
 524 \r
 525         verify765("1997 third day of June = ", c, 1997, Calendar.JUNE, 3);\r
 526 \r
 527         c.clear();\r
 528         c.set(Calendar.YEAR, 1997);\r
 529         c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 530         c.set(Calendar.MONTH, Calendar.JUNE);\r
 531         c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);\r
 532         verify765("1997 first Tuesday in June = ", c, 1997, Calendar.JUNE, 3);\r
 533 \r
 534         c.clear();\r
 535         c.set(Calendar.YEAR, 1997);\r
 536         c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 537         c.set(Calendar.MONTH, Calendar.JUNE);\r
 538         c.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);\r
 539         verify765("1997 last Tuesday in June = ", c, 1997, Calendar.JUNE, 24);\r
 540 \r
 541         IllegalArgumentException e = null;\r
 542         try {\r
 543             c.clear();\r
 544             c.set(Calendar.YEAR, 1997);\r
 545             c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 546             c.set(Calendar.MONTH, Calendar.JUNE);\r
 547             c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 0);\r
 548             c.getTime();\r
 549         }\r
 550         catch (IllegalArgumentException ex) {\r
 551             e = ex;\r
 552         }\r
 553         verify765("1997 zero-th Tuesday in June = ", e, c);\r
 554 \r
 555         c.clear();\r
 556         c.set(Calendar.YEAR, 1997);\r
 557         c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 558         c.set(Calendar.MONTH, Calendar.JUNE);\r
 559         c.set(Calendar.WEEK_OF_MONTH, 1);\r
 560         verify765("1997 Tuesday in week 1 of June = ", c, 1997, Calendar.JUNE, 3);\r
 561 \r
 562         c.clear();\r
 563         c.set(Calendar.YEAR, 1997);\r
 564         c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 565         c.set(Calendar.MONTH, Calendar.JUNE);\r
 566         c.set(Calendar.WEEK_OF_MONTH, 5);\r
 567         verify765("1997 Tuesday in week 5 of June = ", c, 1997, Calendar.JULY, 1);\r
 568 \r
 569         try {\r
 570             c.clear();\r
 571             c.set(Calendar.YEAR, 1997);\r
 572             c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 573             c.set(Calendar.MONTH, Calendar.JUNE);\r
 574             c.set(Calendar.WEEK_OF_MONTH, 0);\r
 575             c.getTime();\r
 576         }\r
 577         catch (IllegalArgumentException ex) {\r
 578             e = ex;\r
 579         }\r
 580         verify765("1997 Tuesday in week 0 of June = ", e, c);\r
 581 \r
 582         c.clear();\r
 583         c.set(Calendar.YEAR, 1997);\r
 584         c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 585         c.set(Calendar.WEEK_OF_YEAR, 1);\r
 586         verify765("1997 Tuesday in week 1 of year = ", c, 1996, Calendar.DECEMBER, 31);\r
 587 \r
 588         c.clear();\r
 589         c.set(Calendar.YEAR, 1997);\r
 590         c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 591         c.set(Calendar.WEEK_OF_YEAR, 10);\r
 592         verify765("1997 Tuesday in week 10 of year = ", c, 1997, Calendar.MARCH, 4);\r
 593 \r
 594         e = null;\r
 595         try {\r
 596             c.clear();\r
 597             c.set(Calendar.YEAR, 1997);\r
 598             c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
 599             c.set(Calendar.WEEK_OF_YEAR, 0);\r
 600             c.getTime();\r
 601         }\r
 602         catch (IllegalArgumentException ex) {\r
 603             e = ex;\r
 604         }\r
 605         verify765("1997 Tuesday in week 0 of year = ", e, c);\r
 606     }\r
 607     void verify765(String msg, Calendar c, int year, int month, int day) {\r
 608         int cy = c.get(Calendar.YEAR); // NEWCAL\r
 609         int cm = c.get(Calendar.MONTH);\r
 610         int cd = c.get(Calendar.DATE);\r
 611         if (cy == year &&\r
 612             cm == month &&\r
 613             cd == day) {\r
 614             logln("PASS: " + msg + c.getTime());\r
 615         }\r
 616         else {\r
 617             errln("FAIL: " + msg + cy + "/" + (cm+1) + "/" + cd +\r
 618                   "=" + c.getTime() +\r
 619                   "; expected " +\r
 620                   year + "/" + (month+1) + "/" + day);\r
 621         }\r
 622     }\r
 623     // Called when e expected to be non-null\r
 624     void verify765(String msg, IllegalArgumentException e, Calendar c) {\r
 625         if (e == null) errln("FAIL: No IllegalArgumentException for " + msg +\r
 626                              c.getTime());\r
 627         else logln("PASS: " + msg + "IllegalArgument as expected");\r
 628     }\r
 629 \r
 630     // Test the behavior of GMT vs. local time\r
 631     public void TestGMTvsLocal4064654() {\r
 632         // Sample output 1:\r
 633         // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 1 1 12 0 0\r
 634         // date = Wed Jan 01 04:00:00 PST 1997\r
 635         // offset for Wed Jan 01 04:00:00 PST 1997= -8hr\r
 636         aux4064654(1997, 1, 1, 12, 0, 0);\r
 637 \r
 638         // Sample output 2:\r
 639         // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 4 16 18 30 0\r
 640         // date = Wed Apr 16 10:30:00 PDT 1997\r
 641         // offset for Wed Apr 16 10:30:00 PDT 1997= -7hr\r
 642 \r
 643         // Note that in sample output 2 according to the offset, the gmt time\r
 644         // of the result would be 1997 4 16 17 30 0 which is different from the\r
 645         // input of 1997 4 16 18 30 0.\r
 646         aux4064654(1997, 4, 16, 18, 30, 0);\r
 647     }\r
 648     void aux4064654(int yr, int mo, int dt, int hr, int mn, int sc) {\r
 649         Date date;\r
 650         Calendar gmtcal = Calendar.getInstance();\r
 651         gmtcal.setTimeZone(TimeZone.getTimeZone("Africa/Casablanca"));\r
 652         gmtcal.set(yr, mo-1, dt, hr, mn, sc);\r
 653         gmtcal.set(Calendar.MILLISECOND, 0);\r
 654 \r
 655         date = gmtcal.getTime();\r
 656         logln("date = "+date);\r
 657 \r
 658         Calendar cal = Calendar.getInstance();\r
 659         cal.setTimeZone(TimeZone.getTimeZone("America/Los_Angels"));\r
 660         cal.setTime(date);\r
 661 \r
 662         int offset = cal.getTimeZone().getOffset(cal.get(Calendar.ERA),\r
 663                                                  cal.get(Calendar.YEAR),\r
 664                                                  cal.get(Calendar.MONTH),\r
 665                                                  cal.get(Calendar.DATE),\r
 666                                                  cal.get(Calendar.DAY_OF_WEEK),\r
 667                                                  cal.get(Calendar.MILLISECOND));\r
 668 \r
 669         logln("offset for "+date+"= "+(offset/1000/60/60.0) + "hr");\r
 670 \r
 671         int utc = ((cal.get(Calendar.HOUR_OF_DAY) * 60 +\r
 672                     cal.get(Calendar.MINUTE)) * 60 +\r
 673                    cal.get(Calendar.SECOND)) * 1000 +\r
 674             cal.get(Calendar.MILLISECOND) - offset;\r
 675 \r
 676         int expected = ((hr * 60 + mn) * 60 + sc) * 1000;\r
 677 \r
 678         if (utc != expected)\r
 679             errln("FAIL: Discrepancy of " +\r
 680                   (utc - expected) + " millis = " +\r
 681                   ((utc-expected)/1000/60/60.0) + " hr");\r
 682     }\r
 683 \r
 684     // Verify that add and set work regardless of the order in which\r
 685     // they are called.\r
 686     public void TestAddSetOrder621() {\r
 687         java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
 688         tempcal.clear();\r
 689         tempcal.set(1997, 4, 14, 13, 23, 45);\r
 690         Date d = tempcal.getTime();\r
 691 \r
 692         Calendar cal = Calendar.getInstance ();\r
 693         cal.setTime (d);\r
 694         cal.add (Calendar.DATE, -5);\r
 695         cal.set (Calendar.HOUR_OF_DAY, 0);\r
 696         cal.set (Calendar.MINUTE, 0);\r
 697         cal.set (Calendar.SECOND, 0);\r
 698         // ma feb 03 00:00:00 GMT+00:00 1997\r
 699         String s = cal.getTime ().toString ();\r
 700 \r
 701         cal = Calendar.getInstance ();\r
 702         cal.setTime (d);\r
 703         cal.set (Calendar.HOUR_OF_DAY, 0);\r
 704         cal.set (Calendar.MINUTE, 0);\r
 705         cal.set (Calendar.SECOND, 0);\r
 706         cal.add (Calendar.DATE, -5);\r
 707         // ma feb 03 13:11:06 GMT+00:00 1997\r
 708         String s2 = cal.getTime ().toString ();\r
 709 \r
 710         if (s.equals(s2))\r
 711             logln("Pass: " + s + " == " + s2);\r
 712         else\r
 713             errln("FAIL: " + s + " != " + s2);\r
 714     }\r
 715 \r
 716     // Verify that add works.\r
 717     public void TestAdd520() {\r
 718         int y = 1997, m = Calendar.FEBRUARY, d = 1;\r
 719         GregorianCalendar temp = new GregorianCalendar( y, m, d );\r
 720         check520(temp, y, m, d);\r
 721 \r
 722         temp.add( Calendar.YEAR, 1 );\r
 723         y++;\r
 724         check520(temp, y, m, d);\r
 725 \r
 726         temp.add( Calendar.MONTH, 1 );\r
 727         m++;\r
 728         check520(temp, y, m, d);\r
 729 \r
 730         temp.add( Calendar.DATE, 1 );\r
 731         d++;\r
 732         check520(temp, y, m, d);\r
 733 \r
 734         temp.add( Calendar.DATE, 2 );\r
 735         d += 2;\r
 736         check520(temp, y, m, d);\r
 737 \r
 738         temp.add( Calendar.DATE, 28 );\r
 739         d = 1; ++m;\r
 740         check520(temp, y, m, d);\r
 741     }\r
 742     void check520(Calendar c, int y, int m, int d) {\r
 743         if (c.get(Calendar.YEAR) != y ||\r
 744             c.get(Calendar.MONTH) != m ||\r
 745             c.get(Calendar.DATE) != d) {\r
 746             errln("FAILURE: Expected YEAR/MONTH/DATE of " +\r
 747                   y + "/" + (m+1) + "/" + d +\r
 748                   "; got " +\r
 749                   c.get(Calendar.YEAR) + "/" +\r
 750                   (c.get(Calendar.MONTH)+1) + "/" +\r
 751                   c.get(Calendar.DATE));\r
 752         }\r
 753         else logln("Confirmed: " +\r
 754                    y + "/" + (m+1) + "/" + d);\r
 755     }\r
 756 \r
 757     // Verify that setting fields works.  This test fails when an exception is thrown.\r
 758     public void TestFieldSet4781() {\r
 759         try {\r
 760             GregorianCalendar g = new GregorianCalendar();\r
 761             GregorianCalendar g2 = new GregorianCalendar();\r
 762             // At this point UTC value is set, various fields are not.\r
 763             // Now set to noon.\r
 764             g2.set(Calendar.HOUR, 12);\r
 765             g2.set(Calendar.MINUTE, 0);\r
 766             g2.set(Calendar.SECOND, 0);\r
 767             // At this point the object thinks UTC is NOT set, but fields are set.\r
 768             // The following line will result in IllegalArgumentException because\r
 769             // it thinks the YEAR is set and it is NOT.\r
 770             if (g2.equals(g))\r
 771                 logln("Same");\r
 772             else\r
 773                 logln("Different");\r
 774         }\r
 775         catch (IllegalArgumentException e) {\r
 776             errln("Unexpected exception seen: " + e);\r
 777         }\r
 778     }\r
 779 \r
 780     // Test serialization of a Calendar object\r
 781     public void TestSerialize337() {\r
 782         Calendar cal = Calendar.getInstance();\r
 783 \r
 784         boolean ok = false;\r
 785 \r
 786         try {\r
 787             ByteArrayOutputStream f = new ByteArrayOutputStream();\r
 788             ObjectOutput s = new ObjectOutputStream(f);\r
 789             s.writeObject(PREFIX);\r
 790             s.writeObject(cal);\r
 791             s.writeObject(POSTFIX);\r
 792             f.close();\r
 793 \r
 794             ByteArrayInputStream in = new ByteArrayInputStream(f.toByteArray());\r
 795             ObjectInputStream t = new ObjectInputStream(in);\r
 796             String pre = (String)t.readObject();\r
 797             Calendar c = (Calendar)t.readObject();\r
 798             String post = (String)t.readObject();\r
 799             in.close();\r
 800 \r
 801             ok = pre.equals(PREFIX) &&\r
 802                 post.equals(POSTFIX) &&\r
 803                 cal.equals(c);\r
 804         }\r
 805         catch (IOException e) {\r
 806             errln("FAIL: Exception received:");\r
 807             // e.printStackTrace(log);\r
 808         }\r
 809         catch (ClassNotFoundException e) {\r
 810             errln("FAIL: Exception received:");\r
 811             // e.printStackTrace(log);\r
 812         }\r
 813 \r
 814         if (!ok) errln("Serialization of Calendar object failed.");\r
 815     }\r
 816     static final String PREFIX = "abc";\r
 817     static final String POSTFIX = "def";\r
 818     static final String FILENAME = "tmp337.bin";\r
 819 \r
 820     // Try to zero out the seconds field\r
 821     public void TestSecondsZero121() {\r
 822         Calendar        cal = new GregorianCalendar();\r
 823         // Initialize with current date/time\r
 824         cal.setTime(new Date());\r
 825         // Round down to minute\r
 826         cal.set(Calendar.SECOND, 0);\r
 827         Date    d = cal.getTime();\r
 828         String s = d.toString();\r
 829         if (s.indexOf(":00 ") < 0) errln("Expected to see :00 in " + s);\r
 830     }\r
 831 \r
 832     // Try various sequences of add, set, and get method calls.\r
 833     public void TestAddSetGet0610() {\r
 834         //\r
 835         // Error case 1:\r
 836         // - Upon initialization calendar fields, millis = System.currentTime\r
 837         // - After set is called fields are initialized, time is not\r
 838         // - Addition uses millis which are still *now*\r
 839         //\r
 840         {\r
 841             Calendar calendar = new GregorianCalendar( ) ;\r
 842             calendar.set( 1993, Calendar.JANUARY, 4 ) ;\r
 843             logln( "1A) " + value( calendar ) ) ;\r
 844             calendar.add( Calendar.DATE, 1 ) ;\r
 845             String v = value(calendar);\r
 846             logln( "1B) " + v );\r
 847             logln( "--) 1993/0/5" ) ;\r
 848             if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +\r
 849                                                 "; saw " + v);\r
 850         }\r
 851 \r
 852         //\r
 853         // Error case 2:\r
 854         // - Upon initialization calendar fields set, millis = 0\r
 855         // - Addition uses millis which are still 1970, 0, 1\r
 856         //\r
 857 \r
 858         {\r
 859             Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;\r
 860             logln( "2A) " + value( calendar ) ) ;\r
 861             calendar.add( Calendar.DATE, 1 ) ;\r
 862             String v = value(calendar);\r
 863             logln( "2B) " + v );\r
 864             logln( "--) 1993/0/5" ) ;\r
 865             if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +\r
 866                                                 "; saw " + v);\r
 867         }\r
 868 \r
 869         //\r
 870         // Error case 3:\r
 871         // - Upon initialization calendar fields, millis = 0\r
 872         // - getTime( ) is called which forces the millis to be set\r
 873         // - Addition uses millis which are correct\r
 874         //\r
 875 \r
 876         {\r
 877             Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;\r
 878             logln( "3A) " + value( calendar ) ) ;\r
 879             calendar.getTime( ) ;\r
 880             calendar.add( Calendar.DATE, 1 ) ;\r
 881             String v = value(calendar);\r
 882             logln( "3B) " + v ) ;\r
 883             logln( "--) 1993/0/5" ) ;\r
 884             if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +\r
 885                                                 "; saw " + v);\r
 886         }\r
 887     }\r
 888     static String value( Calendar calendar ) {\r
 889         return( calendar.get( Calendar.YEAR )  + "/" +\r
 890                 calendar.get( Calendar.MONTH ) + "/" +\r
 891                 calendar.get( Calendar.DATE ) ) ;\r
 892     }\r
 893     static String EXPECTED_0610 = "1993/0/5";\r
 894 \r
 895     // Test that certain fields on a certain date are as expected.\r
 896     public void TestFields060() {\r
 897         int year = 1997;\r
 898         int month = java.util.Calendar.OCTOBER;  //october\r
 899         int dDate = 22;   //DAYOFWEEK should return 3 for Wednesday\r
 900         GregorianCalendar calendar = null;\r
 901 \r
 902         calendar = new GregorianCalendar( year, month, dDate);\r
 903         for (int i=0; i<EXPECTED_FIELDS.length; ) {\r
 904             int field = EXPECTED_FIELDS[i++];\r
 905             int expected = EXPECTED_FIELDS[i++];\r
 906             if (calendar.get(field) != expected) {\r
 907                 errln("Expected field " + field + " to have value " + expected +\r
 908                       "; received " + calendar.get(field) + " instead");\r
 909             }\r
 910         }\r
 911     }\r
 912     static int EXPECTED_FIELDS[] = {\r
 913         Calendar.YEAR, 1997,\r
 914         Calendar.MONTH, Calendar.OCTOBER,\r
 915         Calendar.DAY_OF_MONTH, 22,\r
 916         Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY,\r
 917         Calendar.DAY_OF_WEEK_IN_MONTH, 4,\r
 918         Calendar.DAY_OF_YEAR, 295\r
 919     };\r
 920 \r
 921     // Verify that the fields are as expected (mostly zero) at the epoch start.\r
 922     // Note that we adjust for the default timezone to get most things to zero.\r
 923     public void TestEpochStartFields() {\r
 924         TimeZone z = TimeZone.getDefault();\r
 925         Calendar c = Calendar.getInstance();\r
 926         Date d = new Date(-z.getRawOffset());\r
 927         if (z.inDaylightTime(d)) {\r
 928             logln("Warning: Skipping test because " + d +\r
 929                   " is in DST.");\r
 930         }\r
 931         else {\r
 932             c.setTime(d);\r
 933             c.setMinimalDaysInFirstWeek(1);\r
 934             for (int i=0; i<Calendar.ZONE_OFFSET; ++i) {\r
 935                 if (c.get(i) != EPOCH_FIELDS[i])\r
 936                     errln("Expected field " + i + " to have value " + EPOCH_FIELDS[i] +\r
 937                           "; saw " + c.get(i) + " instead");\r
 938             }\r
 939             if (c.get(Calendar.ZONE_OFFSET) != z.getRawOffset())\r
 940                 errln("Expected field ZONE_OFFSET to have value " + z.getRawOffset() +\r
 941                       "; saw " + c.get(Calendar.ZONE_OFFSET) + " instead");\r
 942             if (c.get(Calendar.DST_OFFSET) != 0)\r
 943                 errln("Expected field DST_OFFSET to have value 0" +\r
 944                       "; saw " + c.get(Calendar.DST_OFFSET) + " instead");\r
 945         }\r
 946     }\r
 947     // These are the fields at the epoch start\r
 948     static int EPOCH_FIELDS[] = { 1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0 };\r
 949 \r
 950     // Verify that as you add days to the calendar (e.g., 24 day periods),\r
 951     // the day of the week shifts in the expected pattern.\r
 952     public void TestDOWProgression() {\r
 953         Calendar cal =\r
 954             new GregorianCalendar(1972, Calendar.OCTOBER, 26);\r
 955         marchByDelta(cal, 24); // Last parameter must be != 0 modulo 7\r
 956     }\r
 957 \r
 958     // Supply a delta which is not a multiple of 7.\r
 959     void marchByDelta(Calendar cal, int delta) {\r
 960         Calendar cur = (Calendar)cal.clone();\r
 961         int initialDOW = cur.get(Calendar.DAY_OF_WEEK);\r
 962         int DOW, newDOW = initialDOW;\r
 963         do {\r
 964             DOW = newDOW;\r
 965             logln("DOW = " + DOW + "  " + cur.getTime());\r
 966 \r
 967             cur.add(Calendar.DAY_OF_WEEK, delta);\r
 968             newDOW = cur.get(Calendar.DAY_OF_WEEK);\r
 969             int expectedDOW = 1 + (DOW + delta - 1) % 7;\r
 970             if (newDOW != expectedDOW) {\r
 971                 errln("Day of week should be " + expectedDOW +\r
 972                       " instead of " + newDOW + " on " + cur.getTime());\r
 973                 return;\r
 974             }\r
 975         }\r
 976         while (newDOW != initialDOW);\r
 977     }\r
 978 \r
 979     public void TestActualMinMax() {\r
 980         Calendar cal = new GregorianCalendar(1967, Calendar.MARCH, 10);\r
 981         cal.setFirstDayOfWeek(Calendar.SUNDAY);\r
 982         cal.setMinimalDaysInFirstWeek(3);\r
 983 \r
 984         if (cal.getActualMinimum(Calendar.DAY_OF_MONTH) != 1)\r
 985             errln("Actual minimum date for 3/10/1967 should have been 1; got " +\r
 986                   cal.getActualMinimum(Calendar.DAY_OF_MONTH));\r
 987         if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 31)\r
 988             errln("Actual maximum date for 3/10/1967 should have been 31; got " +\r
 989                   cal.getActualMaximum(Calendar.DAY_OF_MONTH));\r
 990 \r
 991         cal.set(Calendar.MONTH, Calendar.FEBRUARY);\r
 992         if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 28)\r
 993             errln("Actual maximum date for 2/10/1967 should have been 28; got " +\r
 994                   cal.getActualMaximum(Calendar.DAY_OF_MONTH));\r
 995         if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 365)\r
 996             errln("Number of days in 1967 should have been 365; got " +\r
 997                   cal.getActualMaximum(Calendar.DAY_OF_YEAR));\r
 998 \r
 999         cal.set(Calendar.YEAR, 1968);\r
1000         if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 29)\r
1001             errln("Actual maximum date for 2/10/1968 should have been 29; got " +\r
1002                   cal.getActualMaximum(Calendar.DAY_OF_MONTH));\r
1003         if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 366)\r
1004             errln("Number of days in 1968 should have been 366; got " +\r
1005                   cal.getActualMaximum(Calendar.DAY_OF_YEAR));\r
1006         // Using week settings of SUNDAY/3 (see above)\r
1007         if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 52)\r
1008             errln("Number of weeks in 1968 should have been 52; got " +\r
1009                   cal.getActualMaximum(Calendar.WEEK_OF_YEAR));\r
1010 \r
1011         cal.set(Calendar.YEAR, 1976);\r
1012         cal.set(Calendar.DAY_OF_WEEK, cal.getFirstDayOfWeek()); // Added - Liu 11/6/00\r
1013         // Using week settings of SUNDAY/3 (see above)\r
1014         if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 53)\r
1015             errln("Number of weeks in 1976 should have been 53; got " +\r
1016                   cal.getActualMaximum(Calendar.WEEK_OF_YEAR));\r
1017     }\r
1018 \r
1019     public void TestRoll() {\r
1020         Calendar cal = new GregorianCalendar(1997, Calendar.JANUARY, 31);\r
1021 \r
1022         int[] dayValues = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 };\r
1023         for (int i = 0; i < dayValues.length; i++) {\r
1024             Calendar cal2 = (Calendar)cal.clone();\r
1025             cal2.roll(Calendar.MONTH, i);\r
1026             if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues[i])\r
1027                 errln("Rolling the month in 1/31/1997 up by " + i + " should have yielded "\r
1028                       + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "\r
1029                       + ((i + 1) % 12) + "/" + cal2.get(Calendar.DAY_OF_MONTH) + "/1997.");\r
1030         }\r
1031 \r
1032         cal.set(1996, Calendar.FEBRUARY, 29);\r
1033 \r
1034         //int[] monthValues = { 1, 2, 2, 2, 1, 2, 2, 2, 1, 2 };\r
1035         //int[] dayValues2 = { 29, 1, 1, 1, 29, 1, 1, 1, 29, 1 };\r
1036 \r
1037         // I've revised the expected values to make more sense -- rolling\r
1038         // the year should pin the DAY_OF_MONTH. - Liu 11/6/00\r
1039         int[] monthValues = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };\r
1040         int[] dayValues2 = { 29, 28, 28, 28, 29, 28, 28, 28, 29, 28 };\r
1041 \r
1042         for (int i = 0; i < dayValues2.length; i++) {\r
1043             Calendar cal2 = (Calendar)cal.clone();\r
1044             cal2.roll(Calendar.YEAR, i);\r
1045             if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues2[i] || cal2.get(Calendar.MONTH)\r
1046                 != monthValues[i])\r
1047                 errln("Roll 2/29/1996 by " + i + " year: expected "\r
1048                       + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"\r
1049                       + (1996 + i) + ", got "\r
1050                       + (cal2.get(Calendar.MONTH) + 1) + "/" +\r
1051                       cal2.get(Calendar.DAY_OF_MONTH) + "/" + cal2.get(Calendar.YEAR));\r
1052         }\r
1053 \r
1054         // Test rolling hour of day\r
1055         cal.set(Calendar.HOUR_OF_DAY, 0);\r
1056         cal.roll(Calendar.HOUR_OF_DAY, -2);\r
1057         int f = cal.get(Calendar.HOUR_OF_DAY);\r
1058         if (f != 22) errln("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");\r
1059         cal.roll(Calendar.HOUR_OF_DAY, 5);\r
1060         f = cal.get(Calendar.HOUR_OF_DAY);\r
1061         if (f != 3) errln("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");\r
1062         cal.roll(Calendar.HOUR_OF_DAY, 21);\r
1063         f = cal.get(Calendar.HOUR_OF_DAY);\r
1064         if (f != 0) errln("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");\r
1065 \r
1066         // Test rolling hour\r
1067         cal.set(Calendar.HOUR_OF_DAY, 0);\r
1068         cal.roll(Calendar.HOUR, -2);\r
1069         f = cal.get(Calendar.HOUR);\r
1070         if (f != 10) errln("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");\r
1071         cal.roll(Calendar.HOUR, 5);\r
1072         f = cal.get(Calendar.HOUR);\r
1073         if (f != 3) errln("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");\r
1074         cal.roll(Calendar.HOUR, 9);\r
1075         f = cal.get(Calendar.HOUR);\r
1076         if (f != 0) errln("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");\r
1077     }\r
1078 \r
1079     public void TestComputeJulianDay4406() {\r
1080         // jb4406 is probably not a bug, this is to document the behavior\r
1081         GregorianCalendar cal = new GregorianCalendar();\r
1082         final int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;\r
1083         \r
1084         logln("julian day value jumps at changeover");\r
1085         for (int day = 12; day < 18; ++day) {\r
1086             cal.set(1582, 9, day);\r
1087             logln("[" + day + "] " + (cal.getTimeInMillis()/MILLIS_IN_DAY));\r
1088         }\r
1089 \r
1090         logln("\njulian days not accurate before 1 March 0004");\r
1091         for (int day = 1; day < 3; ++day) {\r
1092             cal.set(1, 0, day);\r
1093             logln("[" + day + "] " + (cal.getTimeInMillis()/MILLIS_IN_DAY));\r
1094         }\r
1095 \r
1096         DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG, 0, Locale.getDefault());\r
1097 \r
1098         logln("\nswitchover in 1582");\r
1099         cal.set(1582, 9, 4);\r
1100         logln(fmt.format(cal));\r
1101         cal.add(Calendar.DATE, 1);\r
1102         logln(fmt.format(cal));\r
1103         cal.set(Calendar.JULIAN_DAY, 1721426);\r
1104         logln(fmt.format(cal));\r
1105 \r
1106         logln("\nlate switchover - proleptic Julian");\r
1107         cal.set(1582, 9, 4);\r
1108         cal.setGregorianChange(new Date(Long.MAX_VALUE));\r
1109         logln(fmt.format(cal));\r
1110         cal.add(Calendar.DATE, 1);\r
1111         logln(fmt.format(cal));\r
1112         cal.set(Calendar.JULIAN_DAY, 1721426);\r
1113         logln(fmt.format(cal));\r
1114 \r
1115         logln("\nearly switchover - proleptic Gregorian");\r
1116         cal.set(1582, 9, 4);\r
1117         cal.setGregorianChange(new Date(Long.MIN_VALUE));\r
1118         logln(fmt.format(cal));\r
1119         cal.add(Calendar.DATE, 1);\r
1120         logln(fmt.format(cal));\r
1121         cal.set(Calendar.JULIAN_DAY, 1721426);\r
1122         logln(fmt.format(cal));\r
1123     }\r
1124 }\r
1125 \r
1126 //eof\r