-//##header\r
-/**\r
- *******************************************************************************\r
- * Copyright (C) 2000-2009, International Business Machines Corporation and *\r
- * others. All Rights Reserved. *\r
- *******************************************************************************\r
- */\r
-package com.ibm.icu.dev.test.calendar;\r
-import com.ibm.icu.util.*;\r
-import com.ibm.icu.text.DateFormat;\r
-\r
-import java.util.Date;\r
-import java.util.Locale;\r
-import java.io.*;\r
-\r
-public class CompatibilityTest extends com.ibm.icu.dev.test.TestFmwk {\r
-\r
- public static void main(String argv[]) throws Exception {\r
- new CompatibilityTest().run(argv);\r
- }\r
-\r
- static final String[] FIELD_NAME = {\r
- "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",\r
- "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",\r
- "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",\r
- "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",\r
- "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",\r
- "JULIAN_DAY", "MILLISECONDS_IN_DAY",\r
- };\r
-\r
- /**\r
- * Test the behavior of the GregorianCalendar around the changeover.\r
- */\r
- public void TestGregorianChangeover() {\r
- \r
- java.util.TimeZone jdkGMT = java.util.TimeZone.getTimeZone("GMT");\r
- java.util.Calendar jdkCal = java.util.Calendar.getInstance(jdkGMT);\r
- jdkCal.clear();\r
- jdkCal.set(1582, Calendar.OCTOBER, 15);\r
- \r
-// if(jdkCal instanceof java.util.GregorianCalendar) {\r
-// logln("jdk IS grego");\r
-// java.util.GregorianCalendar jdkgc = (java.util.GregorianCalendar)\r
-// jdkCal;\r
-// logln("jdk change at: " + jdkgc.getGregorianChange() + "(" + jdkgc.getGregorianChange().getTime() +")" );\r
-// } else {\r
-// logln("jdk NOT grego");\r
-// }\r
-\r
- long a = jdkCal.getTime().getTime();\r
- Date c = jdkCal.getTime();\r
- c.toString();\r
- long b = c.getTime();\r
- if(a!=b) {\r
- logln(" " + a + " != " + b);\r
- logln("JDK has Gregorian cutover anomaly (1.5?) - skipping this test.");\r
- return;\r
- }\r
-\r
- Date co = jdkCal.getTime();\r
- logln("Change over (Oct 15 1582) = " + co + " (" + co.getTime() + ")");\r
- final int ONE_DAY = 24*60*60*1000;\r
- TimeZone gmt = TimeZone.getTimeZone("GMT");\r
- GregorianCalendar cal = new GregorianCalendar(gmt);\r
- /*\r
- Changeover -7 days: 1582/9/28 dow=6\r
- Changeover -6 days: 1582/9/29 dow=7\r
- Changeover -5 days: 1582/9/30 dow=1\r
- Changeover -4 days: 1582/10/1 dow=2\r
- Changeover -3 days: 1582/10/2 dow=3\r
- Changeover -2 days: 1582/10/3 dow=4\r
- Changeover -1 days: 1582/10/4 dow=5\r
- Changeover +0 days: 1582/10/15 dow=6\r
- Changeover +1 days: 1582/10/16 dow=7\r
- Changeover +2 days: 1582/10/17 dow=1\r
- Changeover +3 days: 1582/10/18 dow=2\r
- Changeover +4 days: 1582/10/19 dow=3\r
- Changeover +5 days: 1582/10/20 dow=4\r
- Changeover +6 days: 1582/10/21 dow=5\r
- Changeover +7 days: 1582/10/22 dow=6\r
- */\r
- int MON[] = { 9, 9, 9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };\r
- int DOM[] = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };\r
- int DOW[] = { 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6 };\r
- // ^ <-Changeover Fri Oct 15 1582\r
- int j=0;\r
- for (int i=-7; i<=7; ++i, ++j) {\r
- Date d = new Date(co.getTime() + i*ONE_DAY);\r
- cal.setTime(d);\r
- int y = cal.get(Calendar.YEAR), mon = cal.get(Calendar.MONTH)+1-Calendar.JANUARY,\r
- dom = cal.get(Calendar.DATE), dow = cal.get(Calendar.DAY_OF_WEEK);\r
- logln("Changeover " + (i>=0?"+":"") +\r
- i + " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);\r
- if (y != 1582 || mon != MON[j] || dom != DOM[j] || dow != DOW[j])\r
- errln(" Fail: Above line is wrong");\r
- }\r
- }\r
-\r
- /**\r
- * Test the mapping between millis and fields. For the purposes\r
- * of this test, we don't care about timezones and week data\r
- * (first day of week, minimal days in first week).\r
- */\r
- public void TestMapping() {\r
- if (false) {\r
- Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);\r
- Date PURE_JULIAN = new Date(Long.MAX_VALUE);\r
- GregorianCalendar cal =\r
- new GregorianCalendar(TimeZone.getTimeZone("UTC"));\r
- final int EPOCH_JULIAN = 2440588;\r
- final long ONE_DAY = 24*60*60*1000L;\r
- com.ibm.icu.text.SimpleDateFormat fmt =\r
- new com.ibm.icu.text.SimpleDateFormat("EEE MMM dd yyyy G");\r
- /*HH:mm:ss.SSS z*/\r
-\r
- for (int type=0; type<2; ++type) {\r
- System.out.println(type==0 ? "Gregorian" : "Julian");\r
- cal.setGregorianChange(type==0 ? PURE_GREGORIAN : PURE_JULIAN);\r
- fmt.setCalendar(cal);\r
- int[] J = {\r
- 0x7FFFFFFF,\r
- 0x7FFFFFF0,\r
- 0x7F000000,\r
- 0x78000000,\r
- 0x70000000,\r
- 0x60000000,\r
- 0x50000000,\r
- 0x40000000,\r
- 0x30000000,\r
- 0x20000000,\r
- 0x10000000,\r
- };\r
- for (int i=0; i<J.length; ++i) {\r
- String[] lim = new String[2];\r
- long[] ms = new long[2];\r
- int jd = J[i];\r
- for (int sign=0; sign<2; ++sign) {\r
- int julian = jd;\r
- if (sign==0) julian = -julian;\r
- long millis = ((long)julian - EPOCH_JULIAN) * ONE_DAY;\r
- ms[sign] = millis;\r
- cal.setTime(new Date(millis));\r
- lim[sign] = fmt.format(cal.getTime());\r
- }\r
- System.out.println("JD +/-" +\r
- Long.toString(jd, 16) +\r
- ": " + ms[0] + ".." + ms[1] +\r
- ": " + lim[0] + ".." + lim[1]);\r
- }\r
- }\r
- }\r
-\r
- TimeZone saveZone = TimeZone.getDefault();\r
- try {\r
- TimeZone.setDefault(TimeZone.getTimeZone("UTC"));\r
- //NEWCAL\r
- Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);\r
- Date PURE_JULIAN = new Date(Long.MAX_VALUE);\r
- GregorianCalendar cal = new GregorianCalendar();\r
- final int EPOCH_JULIAN = 2440588;\r
- final long ONE_DAY = 24*60*60*1000L;\r
- int[] DATA = {\r
- // Julian# Year Month DOM JULIAN:Year, Month, DOM\r
- 2440588, 1970, Calendar.JANUARY, 1, 1969, Calendar.DECEMBER, 19, \r
- 2415080, 1900, Calendar.MARCH, 1, 1900, Calendar.FEBRUARY, 17,\r
- 2451604, 2000, Calendar.FEBRUARY, 29, 2000, Calendar.FEBRUARY, 16,\r
- 2452269, 2001, Calendar.DECEMBER, 25, 2001, Calendar.DECEMBER, 12,\r
- 2416526, 1904, Calendar.FEBRUARY, 15, 1904, Calendar.FEBRUARY, 2,\r
- 2416656, 1904, Calendar.JUNE, 24, 1904, Calendar.JUNE, 11,\r
- 1721426, 1, Calendar.JANUARY, 1, 1, Calendar.JANUARY, 3,\r
- 2000000, 763, Calendar.SEPTEMBER, 18, 763, Calendar.SEPTEMBER, 14,\r
- 4000000, 6239, Calendar.JULY, 12, 6239, Calendar.MAY, 28,\r
- 8000000, 17191, Calendar.FEBRUARY, 26, 17190, Calendar.OCTOBER, 22,\r
- 10000000, 22666, Calendar.DECEMBER, 20, 22666, Calendar.JULY, 5,\r
- };\r
- for (int i=0; i<DATA.length; i+=7) {\r
- int julian = DATA[i];\r
- int year = DATA[i+1];\r
- int month = DATA[i+2];\r
- int dom = DATA[i+3];\r
- int year2, month2, dom2;\r
- long millis = (julian - EPOCH_JULIAN) * ONE_DAY;\r
- String s;\r
-\r
- // Test Gregorian computation\r
- cal.setGregorianChange(PURE_GREGORIAN);\r
- cal.clear();\r
- cal.set(year, month, dom);\r
- long calMillis = cal.getTime().getTime();\r
- long delta = calMillis - millis;\r
- cal.setTime(new Date(millis));\r
- year2 = cal.get(Calendar.YEAR);\r
- month2 = cal.get(Calendar.MONTH);\r
- dom2 = cal.get(Calendar.DAY_OF_MONTH);\r
- s = "G " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +\r
- " => " + calMillis +\r
- " (" + ((float)delta/ONE_DAY) + " day delta) => " +\r
- year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;\r
- if (delta != 0 || year != year2 || month != month2 ||\r
- dom != dom2) errln(s + " FAIL");\r
- else logln(s);\r
- \r
- // Test Julian computation\r
- year = DATA[i+4];\r
- month = DATA[i+5];\r
- dom = DATA[i+6];\r
- cal.setGregorianChange(PURE_JULIAN);\r
- cal.clear();\r
- cal.set(year, month, dom);\r
- calMillis = cal.getTime().getTime();\r
- delta = calMillis - millis;\r
- cal.setTime(new Date(millis));\r
- year2 = cal.get(Calendar.YEAR);\r
- month2 = cal.get(Calendar.MONTH);\r
- dom2 = cal.get(Calendar.DAY_OF_MONTH);\r
- s = "J " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +\r
- " => " + calMillis +\r
- " (" + ((float)delta/ONE_DAY) + " day delta) => " +\r
- year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;\r
- if (delta != 0 || year != year2 || month != month2 ||\r
- dom != dom2) errln(s + " FAIL");\r
- else logln(s);\r
- }\r
-\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1582, Calendar.OCTOBER, 15);\r
- cal.setGregorianChange(tempcal.getTime());\r
- auxMapping(cal, 1582, Calendar.OCTOBER, 4);\r
- auxMapping(cal, 1582, Calendar.OCTOBER, 15);\r
- auxMapping(cal, 1582, Calendar.OCTOBER, 16);\r
- for (int y=800; y<3000; y+=1+(int)(100*Math.random())) {\r
- for (int m=Calendar.JANUARY; m<=Calendar.DECEMBER; ++m) {\r
- auxMapping(cal, y, m, 15);\r
- }\r
- }\r
- }\r
- finally {\r
- TimeZone.setDefault(saveZone);\r
- }\r
- }\r
- private void auxMapping(Calendar cal, int y, int m, int d) {\r
- cal.clear();\r
- cal.set(y, m, d);\r
- long millis = cal.getTime().getTime();\r
- cal.setTime(new Date(millis));\r
- int year2 = cal.get(Calendar.YEAR);\r
- int month2 = cal.get(Calendar.MONTH);\r
- int dom2 = cal.get(Calendar.DAY_OF_MONTH);\r
- if (y != year2 || m != month2 || dom2 != d)\r
- errln("Round-trip failure: " + y + "-" + (m+1) + "-"+d+" =>ms=> " +\r
- year2 + "-" + (month2+1) + "-" + dom2);\r
- }\r
-\r
- public void TestGenericAPI() {\r
- // not used String str;\r
-\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1990, Calendar.APRIL, 15);\r
- Date when = tempcal.getTime();\r
-\r
- String tzid = "TestZone";\r
- int tzoffset = 123400;\r
-\r
- SimpleTimeZone zone = new SimpleTimeZone(tzoffset, tzid);\r
- Calendar cal = (Calendar)Calendar.getInstance((SimpleTimeZone)zone.clone());\r
-\r
- if (!zone.equals(cal.getTimeZone())) errln("FAIL: Calendar.getTimeZone failed");\r
-\r
- Calendar cal2 = Calendar.getInstance(cal.getTimeZone());\r
-\r
- cal.setTime(when);\r
- cal2.setTime(when);\r
-\r
- if (!(cal.equals(cal2))) errln("FAIL: Calendar.operator== failed");\r
- // if ((*cal != *cal2)) errln("FAIL: Calendar.operator!= failed");\r
- if (!cal.equals(cal2) ||\r
- cal.before(cal2) ||\r
- cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
-\r
- cal2.setTime(new Date(when.getTime() + 1000));\r
- if (cal.equals(cal2) ||\r
- cal2.before(cal) ||\r
- cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
-\r
- cal.roll(Calendar.SECOND, true);\r
- if (!cal.equals(cal2) ||\r
- cal.before(cal2) ||\r
- cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
-\r
- // Roll back to January\r
- cal.roll(Calendar.MONTH, (int)(1 + Calendar.DECEMBER - cal.get(Calendar.MONTH)));\r
- if (cal.equals(cal2) ||\r
- cal2.before(cal) ||\r
- cal.after(cal2)) errln("FAIL: equals/before/after failed");\r
-\r
- // C++ only\r
- /* TimeZone z = cal.orphanTimeZone();\r
- if (z.getID(str) != tzid ||\r
- z.getRawOffset() != tzoffset)\r
- errln("FAIL: orphanTimeZone failed");\r
- */\r
-\r
- for (int i=0; i<2; ++i) {\r
- boolean lenient = ( i > 0 );\r
- cal.setLenient(lenient);\r
- if (lenient != cal.isLenient()) errln("FAIL: setLenient/isLenient failed");\r
- // Later: Check for lenient behavior\r
- }\r
-\r
- int i;\r
- for (i=Calendar.SUNDAY; i<=Calendar.SATURDAY; ++i) {\r
- cal.setFirstDayOfWeek(i);\r
- if (cal.getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");\r
- }\r
-\r
- for (i=1; i<=7; ++i) {\r
- cal.setMinimalDaysInFirstWeek(i);\r
- if (cal.getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");\r
- }\r
-\r
- for (i=0; i<cal.getFieldCount(); ++i) {\r
- if (cal.getMinimum(i) > cal.getGreatestMinimum(i))\r
- errln("FAIL: getMinimum larger than getGreatestMinimum for field " + i);\r
- if (cal.getLeastMaximum(i) > cal.getMaximum(i))\r
- errln("FAIL: getLeastMaximum larger than getMaximum for field " + i);\r
- if (cal.getMinimum(i) >= cal.getMaximum(i))\r
- errln("FAIL: getMinimum not less than getMaximum for field " + i);\r
- }\r
-\r
- cal.setTimeZone(TimeZone.getDefault());\r
- cal.clear();\r
- cal.set(1984, 5, 24);\r
- tempcal.clear();\r
- tempcal.set(1984, 5, 24);\r
- if (cal.getTime().getTime() != tempcal.getTime().getTime()) {\r
- errln("FAIL: Calendar.set(3 args) failed");\r
- logln(" Got: " + cal.getTime() + " Expected: " + tempcal.getTime());\r
- }\r
-\r
-//#if defined(FOUNDATION10) || defined(J2SE13)\r
-//## // This test case does not work well with JRE1.3 with\r
-//## // the timezone update for US 2007 rule. Java 1.3 only\r
-//## // supports single DST rule for all years. April 2, 1985\r
-//## // was actually not in DST, but with the new rule, the date\r
-//## // is in DST (which is actually wrong).\r
-//#else\r
- cal.clear();\r
- cal.set(1985, 2, 2, 11, 49);\r
- tempcal.clear();\r
- tempcal.set(1985, 2, 2, 11, 49);\r
- if (cal.getTime().getTime() != tempcal.getTime().getTime()) {\r
- errln("FAIL: Calendar.set(5 args) failed");\r
- logln(" Got: " + cal.getTime() + " Expected: " + tempcal.getTime());\r
- }\r
-//#endif\r
-\r
- cal.clear();\r
- cal.set(1995, 9, 12, 1, 39, 55);\r
- tempcal.clear();\r
- tempcal.set(1995, 9, 12, 1, 39, 55);\r
- if (cal.getTime().getTime() != tempcal.getTime().getTime()) {\r
- errln("FAIL: Calendar.set(6 args) failed");\r
- logln(" Got: " + cal.getTime() + " Expected: " + tempcal.getTime());\r
- }\r
-\r
- cal.getTime();\r
- // This test is strange -- why do we expect certain fields to be set, and\r
- // others not to be? Revisit the appropriateness of this. - Alan NEWCAL\r
- for (i=0; i<cal.getFieldCount(); ++i) {\r
- switch(i) {\r
- case Calendar.YEAR: case Calendar.MONTH: case Calendar.DATE:\r
- case Calendar.HOUR_OF_DAY: case Calendar.MINUTE: case Calendar.SECOND:\r
- case Calendar.EXTENDED_YEAR:\r
- if (!cal.isSet(i)) errln("FAIL: " + FIELD_NAME[i] + " is not set");\r
- break;\r
- default:\r
- if (cal.isSet(i)) errln("FAIL: " + FIELD_NAME[i] + " is set");\r
- }\r
- cal.clear(i);\r
- if (cal.isSet(i)) errln("FAIL: Calendar.clear/isSet failed");\r
- }\r
-\r
- // delete cal;\r
- // delete cal2;\r
-\r
- Locale[] loc = Calendar.getAvailableLocales();\r
- long count = loc.length;\r
- if (count < 1 || loc == null) {\r
- errln("FAIL: getAvailableLocales failed");\r
- }\r
- else {\r
- for (i=0; i<count; ++i) {\r
- cal = Calendar.getInstance(loc[i]);\r
- // delete cal;\r
- }\r
- }\r
-\r
- cal = Calendar.getInstance(TimeZone.getDefault(), Locale.ENGLISH);\r
- // delete cal;\r
-\r
- cal = Calendar.getInstance(zone, Locale.ENGLISH);\r
- // delete cal;\r
-\r
- GregorianCalendar gc = new GregorianCalendar(zone);\r
- // delete gc;\r
-\r
- gc = new GregorianCalendar(Locale.ENGLISH);\r
- // delete gc;\r
-\r
- gc = new GregorianCalendar(Locale.ENGLISH);\r
- // delete gc;\r
-\r
- gc = new GregorianCalendar(zone, Locale.ENGLISH);\r
- // delete gc;\r
-\r
- gc = new GregorianCalendar(zone);\r
- // delete gc;\r
-\r
- gc = new GregorianCalendar(1998, 10, 14, 21, 43);\r
- tempcal.clear();\r
- tempcal.set(1998, 10, 14, 21, 43);\r
- if (gc.getTime().getTime() != tempcal.getTime().getTime())\r
- errln("FAIL: new GregorianCalendar(ymdhm) failed");\r
- // delete gc;\r
-\r
- gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55);\r
- tempcal.clear();\r
- tempcal.set(1998, 10, 14, 21, 43, 55);\r
- if (gc.getTime().getTime() != tempcal.getTime().getTime())\r
- errln("FAIL: new GregorianCalendar(ymdhms) failed");\r
-\r
- // C++ only:\r
- // GregorianCalendar gc2 = new GregorianCalendar(Locale.ENGLISH);\r
- // gc2 = gc;\r
- // if (gc2 != gc || !(gc2 == gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");\r
- // delete gc;\r
- // delete z;\r
- }\r
-\r
- // Verify Roger Webster's bug\r
- public void TestRog() {\r
- GregorianCalendar gc = new GregorianCalendar();\r
-\r
- int year = 1997, month = Calendar.APRIL, date = 1;\r
- gc.set(year, month, date); // April 1, 1997\r
-\r
- gc.set(Calendar.HOUR_OF_DAY, 23);\r
- gc.set(Calendar.MINUTE, 0);\r
- gc.set(Calendar.SECOND, 0);\r
- gc.set(Calendar.MILLISECOND, 0);\r
-\r
- for (int i = 0; i < 9; i++, gc.add(Calendar.DATE, 1)) {\r
- if (gc.get(Calendar.YEAR) != year ||\r
- gc.get(Calendar.MONTH) != month ||\r
- gc.get(Calendar.DATE) != (date + i))\r
- errln("FAIL: Date " + gc.getTime() + " wrong");\r
- }\r
- }\r
-\r
- // Verify DAY_OF_WEEK\r
- public void TestDOW943() {\r
- dowTest(false);\r
- dowTest(true);\r
- }\r
-\r
- void dowTest(boolean lenient) {\r
- GregorianCalendar cal = new GregorianCalendar();\r
- cal.set(1997, Calendar.AUGUST, 12); // Wednesday\r
- cal.getTime(); // Force update\r
- cal.setLenient(lenient);\r
- cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1, 1996\r
- int dow = cal.get(Calendar.DAY_OF_WEEK);\r
- int min = cal.getMinimum(Calendar.DAY_OF_WEEK);\r
- int max = cal.getMaximum(Calendar.DAY_OF_WEEK);\r
- if (dow < min || dow > max) errln("FAIL: Day of week " + dow + " out of range");\r
- if (dow != Calendar.SUNDAY) {\r
- errln("FAIL2: Day of week should be SUNDAY; is " + dow + ": " + cal.getTime());\r
- }\r
- if (min != Calendar.SUNDAY || max != Calendar.SATURDAY) errln("FAIL: Min/max bad");\r
- }\r
-\r
- // Verify that the clone method produces distinct objects with no\r
- // unintentionally shared fields.\r
- public void TestClonesUnique908() {\r
- Calendar c = Calendar.getInstance();\r
- Calendar d = (Calendar)c.clone();\r
- c.set(Calendar.MILLISECOND, 123);\r
- d.set(Calendar.MILLISECOND, 456);\r
- if (c.get(Calendar.MILLISECOND) != 123 ||\r
- d.get(Calendar.MILLISECOND) != 456) {\r
- errln("FAIL: Clones share fields");\r
- }\r
- }\r
-\r
- // Verify effect of Gregorian cutoff value\r
- public void TestGregorianChange768() {\r
- boolean b;\r
- GregorianCalendar c = new GregorianCalendar();\r
- logln("With cutoff " + c.getGregorianChange());\r
- logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));\r
- logln(" (should be FALSE)");\r
- if (b != false) errln("FAIL");\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1900, 0, 1);\r
- c.setGregorianChange(tempcal.getTime()); // Jan 1 1900\r
- logln("With cutoff " + c.getGregorianChange());\r
- logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));\r
- logln(" (should be TRUE)");\r
- if (b != true) errln("FAIL");\r
- }\r
-\r
- // Test the correct behavior of the disambiguation algorithm.\r
- public void TestDisambiguation765() throws Exception {\r
- Calendar c = Calendar.getInstance();\r
- c.setLenient(false);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.DATE, 3);\r
-\r
- verify765("1997 third day of June = ", c, 1997, Calendar.JUNE, 3);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);\r
- verify765("1997 first Tuesday in June = ", c, 1997, Calendar.JUNE, 3);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);\r
- verify765("1997 last Tuesday in June = ", c, 1997, Calendar.JUNE, 24);\r
-\r
- IllegalArgumentException e = null;\r
- try {\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 0);\r
- c.getTime();\r
- }\r
- catch (IllegalArgumentException ex) {\r
- e = ex;\r
- }\r
- verify765("1997 zero-th Tuesday in June = ", e, c);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.WEEK_OF_MONTH, 1);\r
- verify765("1997 Tuesday in week 1 of June = ", c, 1997, Calendar.JUNE, 3);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.WEEK_OF_MONTH, 5);\r
- verify765("1997 Tuesday in week 5 of June = ", c, 1997, Calendar.JULY, 1);\r
-\r
- try {\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.MONTH, Calendar.JUNE);\r
- c.set(Calendar.WEEK_OF_MONTH, 0);\r
- c.getTime();\r
- }\r
- catch (IllegalArgumentException ex) {\r
- e = ex;\r
- }\r
- verify765("1997 Tuesday in week 0 of June = ", e, c);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.WEEK_OF_YEAR, 1);\r
- verify765("1997 Tuesday in week 1 of year = ", c, 1996, Calendar.DECEMBER, 31);\r
-\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.WEEK_OF_YEAR, 10);\r
- verify765("1997 Tuesday in week 10 of year = ", c, 1997, Calendar.MARCH, 4);\r
-\r
- e = null;\r
- try {\r
- c.clear();\r
- c.set(Calendar.YEAR, 1997);\r
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);\r
- c.set(Calendar.WEEK_OF_YEAR, 0);\r
- c.getTime();\r
- }\r
- catch (IllegalArgumentException ex) {\r
- e = ex;\r
- }\r
- verify765("1997 Tuesday in week 0 of year = ", e, c);\r
- }\r
- void verify765(String msg, Calendar c, int year, int month, int day) {\r
- int cy = c.get(Calendar.YEAR); // NEWCAL\r
- int cm = c.get(Calendar.MONTH);\r
- int cd = c.get(Calendar.DATE);\r
- if (cy == year &&\r
- cm == month &&\r
- cd == day) {\r
- logln("PASS: " + msg + c.getTime());\r
- }\r
- else {\r
- errln("FAIL: " + msg + cy + "/" + (cm+1) + "/" + cd +\r
- "=" + c.getTime() +\r
- "; expected " +\r
- year + "/" + (month+1) + "/" + day);\r
- }\r
- }\r
- // Called when e expected to be non-null\r
- void verify765(String msg, IllegalArgumentException e, Calendar c) {\r
- if (e == null) errln("FAIL: No IllegalArgumentException for " + msg +\r
- c.getTime());\r
- else logln("PASS: " + msg + "IllegalArgument as expected");\r
- }\r
-\r
- // Test the behavior of GMT vs. local time\r
- public void TestGMTvsLocal4064654() {\r
- // Sample output 1:\r
- // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 1 1 12 0 0\r
- // date = Wed Jan 01 04:00:00 PST 1997\r
- // offset for Wed Jan 01 04:00:00 PST 1997= -8hr\r
- aux4064654(1997, 1, 1, 12, 0, 0);\r
-\r
- // Sample output 2:\r
- // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 4 16 18 30 0\r
- // date = Wed Apr 16 10:30:00 PDT 1997\r
- // offset for Wed Apr 16 10:30:00 PDT 1997= -7hr\r
-\r
- // Note that in sample output 2 according to the offset, the gmt time\r
- // of the result would be 1997 4 16 17 30 0 which is different from the\r
- // input of 1997 4 16 18 30 0.\r
- aux4064654(1997, 4, 16, 18, 30, 0);\r
- }\r
- void aux4064654(int yr, int mo, int dt, int hr, int mn, int sc) {\r
- Date date;\r
- Calendar gmtcal = Calendar.getInstance();\r
- gmtcal.setTimeZone(TimeZone.getTimeZone("Africa/Casablanca"));\r
- gmtcal.set(yr, mo-1, dt, hr, mn, sc);\r
- gmtcal.set(Calendar.MILLISECOND, 0);\r
-\r
- date = gmtcal.getTime();\r
- logln("date = "+date);\r
-\r
- Calendar cal = Calendar.getInstance();\r
- cal.setTimeZone(TimeZone.getTimeZone("America/Los_Angels"));\r
- cal.setTime(date);\r
-\r
- int offset = cal.getTimeZone().getOffset(cal.get(Calendar.ERA),\r
- cal.get(Calendar.YEAR),\r
- cal.get(Calendar.MONTH),\r
- cal.get(Calendar.DATE),\r
- cal.get(Calendar.DAY_OF_WEEK),\r
- cal.get(Calendar.MILLISECOND));\r
-\r
- logln("offset for "+date+"= "+(offset/1000/60/60.0) + "hr");\r
-\r
- int utc = ((cal.get(Calendar.HOUR_OF_DAY) * 60 +\r
- cal.get(Calendar.MINUTE)) * 60 +\r
- cal.get(Calendar.SECOND)) * 1000 +\r
- cal.get(Calendar.MILLISECOND) - offset;\r
-\r
- int expected = ((hr * 60 + mn) * 60 + sc) * 1000;\r
-\r
- if (utc != expected)\r
- errln("FAIL: Discrepancy of " +\r
- (utc - expected) + " millis = " +\r
- ((utc-expected)/1000/60/60.0) + " hr");\r
- }\r
-\r
- // Verify that add and set work regardless of the order in which\r
- // they are called.\r
- public void TestAddSetOrder621() {\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1997, 4, 14, 13, 23, 45);\r
- Date d = tempcal.getTime();\r
-\r
- Calendar cal = Calendar.getInstance ();\r
- cal.setTime (d);\r
- cal.add (Calendar.DATE, -5);\r
- cal.set (Calendar.HOUR_OF_DAY, 0);\r
- cal.set (Calendar.MINUTE, 0);\r
- cal.set (Calendar.SECOND, 0);\r
- // ma feb 03 00:00:00 GMT+00:00 1997\r
- String s = cal.getTime ().toString ();\r
-\r
- cal = Calendar.getInstance ();\r
- cal.setTime (d);\r
- cal.set (Calendar.HOUR_OF_DAY, 0);\r
- cal.set (Calendar.MINUTE, 0);\r
- cal.set (Calendar.SECOND, 0);\r
- cal.add (Calendar.DATE, -5);\r
- // ma feb 03 13:11:06 GMT+00:00 1997\r
- String s2 = cal.getTime ().toString ();\r
-\r
- if (s.equals(s2))\r
- logln("Pass: " + s + " == " + s2);\r
- else\r
- errln("FAIL: " + s + " != " + s2);\r
- }\r
-\r
- // Verify that add works.\r
- public void TestAdd520() {\r
- int y = 1997, m = Calendar.FEBRUARY, d = 1;\r
- GregorianCalendar temp = new GregorianCalendar( y, m, d );\r
- check520(temp, y, m, d);\r
-\r
- temp.add( Calendar.YEAR, 1 );\r
- y++;\r
- check520(temp, y, m, d);\r
-\r
- temp.add( Calendar.MONTH, 1 );\r
- m++;\r
- check520(temp, y, m, d);\r
-\r
- temp.add( Calendar.DATE, 1 );\r
- d++;\r
- check520(temp, y, m, d);\r
-\r
- temp.add( Calendar.DATE, 2 );\r
- d += 2;\r
- check520(temp, y, m, d);\r
-\r
- temp.add( Calendar.DATE, 28 );\r
- d = 1; ++m;\r
- check520(temp, y, m, d);\r
- }\r
- void check520(Calendar c, int y, int m, int d) {\r
- if (c.get(Calendar.YEAR) != y ||\r
- c.get(Calendar.MONTH) != m ||\r
- c.get(Calendar.DATE) != d) {\r
- errln("FAILURE: Expected YEAR/MONTH/DATE of " +\r
- y + "/" + (m+1) + "/" + d +\r
- "; got " +\r
- c.get(Calendar.YEAR) + "/" +\r
- (c.get(Calendar.MONTH)+1) + "/" +\r
- c.get(Calendar.DATE));\r
- }\r
- else logln("Confirmed: " +\r
- y + "/" + (m+1) + "/" + d);\r
- }\r
-\r
- // Verify that setting fields works. This test fails when an exception is thrown.\r
- public void TestFieldSet4781() {\r
- try {\r
- GregorianCalendar g = new GregorianCalendar();\r
- GregorianCalendar g2 = new GregorianCalendar();\r
- // At this point UTC value is set, various fields are not.\r
- // Now set to noon.\r
- g2.set(Calendar.HOUR, 12);\r
- g2.set(Calendar.MINUTE, 0);\r
- g2.set(Calendar.SECOND, 0);\r
- // At this point the object thinks UTC is NOT set, but fields are set.\r
- // The following line will result in IllegalArgumentException because\r
- // it thinks the YEAR is set and it is NOT.\r
- if (g2.equals(g))\r
- logln("Same");\r
- else\r
- logln("Different");\r
- }\r
- catch (IllegalArgumentException e) {\r
- errln("Unexpected exception seen: " + e);\r
- }\r
- }\r
-\r
- // Test serialization of a Calendar object\r
- public void TestSerialize337() {\r
- Calendar cal = Calendar.getInstance();\r
-\r
- boolean ok = false;\r
-\r
- try {\r
- ByteArrayOutputStream f = new ByteArrayOutputStream();\r
- ObjectOutput s = new ObjectOutputStream(f);\r
- s.writeObject(PREFIX);\r
- s.writeObject(cal);\r
- s.writeObject(POSTFIX);\r
- f.close();\r
-\r
- ByteArrayInputStream in = new ByteArrayInputStream(f.toByteArray());\r
- ObjectInputStream t = new ObjectInputStream(in);\r
- String pre = (String)t.readObject();\r
- Calendar c = (Calendar)t.readObject();\r
- String post = (String)t.readObject();\r
- in.close();\r
-\r
- ok = pre.equals(PREFIX) &&\r
- post.equals(POSTFIX) &&\r
- cal.equals(c);\r
- }\r
- catch (IOException e) {\r
- errln("FAIL: Exception received:");\r
- // e.printStackTrace(log);\r
- }\r
- catch (ClassNotFoundException e) {\r
- errln("FAIL: Exception received:");\r
- // e.printStackTrace(log);\r
- }\r
-\r
- if (!ok) errln("Serialization of Calendar object failed.");\r
- }\r
- static final String PREFIX = "abc";\r
- static final String POSTFIX = "def";\r
- static final String FILENAME = "tmp337.bin";\r
-\r
- // Try to zero out the seconds field\r
- public void TestSecondsZero121() {\r
- Calendar cal = new GregorianCalendar();\r
- // Initialize with current date/time\r
- cal.setTime(new Date());\r
- // Round down to minute\r
- cal.set(Calendar.SECOND, 0);\r
- Date d = cal.getTime();\r
- String s = d.toString();\r
- if (s.indexOf(":00 ") < 0) errln("Expected to see :00 in " + s);\r
- }\r
-\r
- // Try various sequences of add, set, and get method calls.\r
- public void TestAddSetGet0610() {\r
- //\r
- // Error case 1:\r
- // - Upon initialization calendar fields, millis = System.currentTime\r
- // - After set is called fields are initialized, time is not\r
- // - Addition uses millis which are still *now*\r
- //\r
- {\r
- Calendar calendar = new GregorianCalendar( ) ;\r
- calendar.set( 1993, Calendar.JANUARY, 4 ) ;\r
- logln( "1A) " + value( calendar ) ) ;\r
- calendar.add( Calendar.DATE, 1 ) ;\r
- String v = value(calendar);\r
- logln( "1B) " + v );\r
- logln( "--) 1993/0/5" ) ;\r
- if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +\r
- "; saw " + v);\r
- }\r
-\r
- //\r
- // Error case 2:\r
- // - Upon initialization calendar fields set, millis = 0\r
- // - Addition uses millis which are still 1970, 0, 1\r
- //\r
-\r
- {\r
- Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;\r
- logln( "2A) " + value( calendar ) ) ;\r
- calendar.add( Calendar.DATE, 1 ) ;\r
- String v = value(calendar);\r
- logln( "2B) " + v );\r
- logln( "--) 1993/0/5" ) ;\r
- if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +\r
- "; saw " + v);\r
- }\r
-\r
- //\r
- // Error case 3:\r
- // - Upon initialization calendar fields, millis = 0\r
- // - getTime( ) is called which forces the millis to be set\r
- // - Addition uses millis which are correct\r
- //\r
-\r
- {\r
- Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;\r
- logln( "3A) " + value( calendar ) ) ;\r
- calendar.getTime( ) ;\r
- calendar.add( Calendar.DATE, 1 ) ;\r
- String v = value(calendar);\r
- logln( "3B) " + v ) ;\r
- logln( "--) 1993/0/5" ) ;\r
- if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +\r
- "; saw " + v);\r
- }\r
- }\r
- static String value( Calendar calendar ) {\r
- return( calendar.get( Calendar.YEAR ) + "/" +\r
- calendar.get( Calendar.MONTH ) + "/" +\r
- calendar.get( Calendar.DATE ) ) ;\r
- }\r
- static String EXPECTED_0610 = "1993/0/5";\r
-\r
- // Test that certain fields on a certain date are as expected.\r
- public void TestFields060() {\r
- int year = 1997;\r
- int month = java.util.Calendar.OCTOBER; //october\r
- int dDate = 22; //DAYOFWEEK should return 3 for Wednesday\r
- GregorianCalendar calendar = null;\r
-\r
- calendar = new GregorianCalendar( year, month, dDate);\r
- for (int i=0; i<EXPECTED_FIELDS.length; ) {\r
- int field = EXPECTED_FIELDS[i++];\r
- int expected = EXPECTED_FIELDS[i++];\r
- if (calendar.get(field) != expected) {\r
- errln("Expected field " + field + " to have value " + expected +\r
- "; received " + calendar.get(field) + " instead");\r
- }\r
- }\r
- }\r
- static int EXPECTED_FIELDS[] = {\r
- Calendar.YEAR, 1997,\r
- Calendar.MONTH, Calendar.OCTOBER,\r
- Calendar.DAY_OF_MONTH, 22,\r
- Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY,\r
- Calendar.DAY_OF_WEEK_IN_MONTH, 4,\r
- Calendar.DAY_OF_YEAR, 295\r
- };\r
-\r
- // Verify that the fields are as expected (mostly zero) at the epoch start.\r
- // Note that we adjust for the default timezone to get most things to zero.\r
- public void TestEpochStartFields() {\r
- TimeZone z = TimeZone.getDefault();\r
- Calendar c = Calendar.getInstance();\r
- Date d = new Date(-z.getRawOffset());\r
- if (z.inDaylightTime(d)) {\r
- logln("Warning: Skipping test because " + d +\r
- " is in DST.");\r
- }\r
- else {\r
- c.setTime(d);\r
- c.setMinimalDaysInFirstWeek(1);\r
- for (int i=0; i<Calendar.ZONE_OFFSET; ++i) {\r
- if (c.get(i) != EPOCH_FIELDS[i])\r
- errln("Expected field " + i + " to have value " + EPOCH_FIELDS[i] +\r
- "; saw " + c.get(i) + " instead");\r
- }\r
- if (c.get(Calendar.ZONE_OFFSET) != z.getRawOffset())\r
- errln("Expected field ZONE_OFFSET to have value " + z.getRawOffset() +\r
- "; saw " + c.get(Calendar.ZONE_OFFSET) + " instead");\r
- if (c.get(Calendar.DST_OFFSET) != 0)\r
- errln("Expected field DST_OFFSET to have value 0" +\r
- "; saw " + c.get(Calendar.DST_OFFSET) + " instead");\r
- }\r
- }\r
- // These are the fields at the epoch start\r
- static int EPOCH_FIELDS[] = { 1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0 };\r
-\r
- // Verify that as you add days to the calendar (e.g., 24 day periods),\r
- // the day of the week shifts in the expected pattern.\r
- public void TestDOWProgression() {\r
- Calendar cal =\r
- new GregorianCalendar(1972, Calendar.OCTOBER, 26);\r
- marchByDelta(cal, 24); // Last parameter must be != 0 modulo 7\r
- }\r
-\r
- // Supply a delta which is not a multiple of 7.\r
- void marchByDelta(Calendar cal, int delta) {\r
- Calendar cur = (Calendar)cal.clone();\r
- int initialDOW = cur.get(Calendar.DAY_OF_WEEK);\r
- int DOW, newDOW = initialDOW;\r
- do {\r
- DOW = newDOW;\r
- logln("DOW = " + DOW + " " + cur.getTime());\r
-\r
- cur.add(Calendar.DAY_OF_WEEK, delta);\r
- newDOW = cur.get(Calendar.DAY_OF_WEEK);\r
- int expectedDOW = 1 + (DOW + delta - 1) % 7;\r
- if (newDOW != expectedDOW) {\r
- errln("Day of week should be " + expectedDOW +\r
- " instead of " + newDOW + " on " + cur.getTime());\r
- return;\r
- }\r
- }\r
- while (newDOW != initialDOW);\r
- }\r
-\r
- public void TestActualMinMax() {\r
- Calendar cal = new GregorianCalendar(1967, Calendar.MARCH, 10);\r
- cal.setFirstDayOfWeek(Calendar.SUNDAY);\r
- cal.setMinimalDaysInFirstWeek(3);\r
-\r
- if (cal.getActualMinimum(Calendar.DAY_OF_MONTH) != 1)\r
- errln("Actual minimum date for 3/10/1967 should have been 1; got " +\r
- cal.getActualMinimum(Calendar.DAY_OF_MONTH));\r
- if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 31)\r
- errln("Actual maximum date for 3/10/1967 should have been 31; got " +\r
- cal.getActualMaximum(Calendar.DAY_OF_MONTH));\r
-\r
- cal.set(Calendar.MONTH, Calendar.FEBRUARY);\r
- if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 28)\r
- errln("Actual maximum date for 2/10/1967 should have been 28; got " +\r
- cal.getActualMaximum(Calendar.DAY_OF_MONTH));\r
- if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 365)\r
- errln("Number of days in 1967 should have been 365; got " +\r
- cal.getActualMaximum(Calendar.DAY_OF_YEAR));\r
-\r
- cal.set(Calendar.YEAR, 1968);\r
- if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 29)\r
- errln("Actual maximum date for 2/10/1968 should have been 29; got " +\r
- cal.getActualMaximum(Calendar.DAY_OF_MONTH));\r
- if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 366)\r
- errln("Number of days in 1968 should have been 366; got " +\r
- cal.getActualMaximum(Calendar.DAY_OF_YEAR));\r
- // Using week settings of SUNDAY/3 (see above)\r
- if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 52)\r
- errln("Number of weeks in 1968 should have been 52; got " +\r
- cal.getActualMaximum(Calendar.WEEK_OF_YEAR));\r
-\r
- cal.set(Calendar.YEAR, 1976);\r
- cal.set(Calendar.DAY_OF_WEEK, cal.getFirstDayOfWeek()); // Added - Liu 11/6/00\r
- // Using week settings of SUNDAY/3 (see above)\r
- if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 53)\r
- errln("Number of weeks in 1976 should have been 53; got " +\r
- cal.getActualMaximum(Calendar.WEEK_OF_YEAR));\r
- }\r
-\r
- public void TestRoll() {\r
- Calendar cal = new GregorianCalendar(1997, Calendar.JANUARY, 31);\r
-\r
- int[] dayValues = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 };\r
- for (int i = 0; i < dayValues.length; i++) {\r
- Calendar cal2 = (Calendar)cal.clone();\r
- cal2.roll(Calendar.MONTH, i);\r
- if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues[i])\r
- errln("Rolling the month in 1/31/1997 up by " + i + " should have yielded "\r
- + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "\r
- + ((i + 1) % 12) + "/" + cal2.get(Calendar.DAY_OF_MONTH) + "/1997.");\r
- }\r
-\r
- cal.set(1996, Calendar.FEBRUARY, 29);\r
-\r
- //int[] monthValues = { 1, 2, 2, 2, 1, 2, 2, 2, 1, 2 };\r
- //int[] dayValues2 = { 29, 1, 1, 1, 29, 1, 1, 1, 29, 1 };\r
-\r
- // I've revised the expected values to make more sense -- rolling\r
- // the year should pin the DAY_OF_MONTH. - Liu 11/6/00\r
- int[] monthValues = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };\r
- int[] dayValues2 = { 29, 28, 28, 28, 29, 28, 28, 28, 29, 28 };\r
-\r
- for (int i = 0; i < dayValues2.length; i++) {\r
- Calendar cal2 = (Calendar)cal.clone();\r
- cal2.roll(Calendar.YEAR, i);\r
- if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues2[i] || cal2.get(Calendar.MONTH)\r
- != monthValues[i])\r
- errln("Roll 2/29/1996 by " + i + " year: expected "\r
- + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"\r
- + (1996 + i) + ", got "\r
- + (cal2.get(Calendar.MONTH) + 1) + "/" +\r
- cal2.get(Calendar.DAY_OF_MONTH) + "/" + cal2.get(Calendar.YEAR));\r
- }\r
-\r
- // Test rolling hour of day\r
- cal.set(Calendar.HOUR_OF_DAY, 0);\r
- cal.roll(Calendar.HOUR_OF_DAY, -2);\r
- int f = cal.get(Calendar.HOUR_OF_DAY);\r
- if (f != 22) errln("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");\r
- cal.roll(Calendar.HOUR_OF_DAY, 5);\r
- f = cal.get(Calendar.HOUR_OF_DAY);\r
- if (f != 3) errln("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");\r
- cal.roll(Calendar.HOUR_OF_DAY, 21);\r
- f = cal.get(Calendar.HOUR_OF_DAY);\r
- if (f != 0) errln("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");\r
-\r
- // Test rolling hour\r
- cal.set(Calendar.HOUR_OF_DAY, 0);\r
- cal.roll(Calendar.HOUR, -2);\r
- f = cal.get(Calendar.HOUR);\r
- if (f != 10) errln("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");\r
- cal.roll(Calendar.HOUR, 5);\r
- f = cal.get(Calendar.HOUR);\r
- if (f != 3) errln("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");\r
- cal.roll(Calendar.HOUR, 9);\r
- f = cal.get(Calendar.HOUR);\r
- if (f != 0) errln("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");\r
- }\r
-\r
- public void TestComputeJulianDay4406() {\r
- // jb4406 is probably not a bug, this is to document the behavior\r
- GregorianCalendar cal = new GregorianCalendar();\r
- final int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;\r
- \r
- logln("julian day value jumps at changeover");\r
- for (int day = 12; day < 18; ++day) {\r
- cal.set(1582, 9, day);\r
- logln("[" + day + "] " + (cal.getTimeInMillis()/MILLIS_IN_DAY));\r
- }\r
-\r
- logln("\njulian days not accurate before 1 March 0004");\r
- for (int day = 1; day < 3; ++day) {\r
- cal.set(1, 0, day);\r
- logln("[" + day + "] " + (cal.getTimeInMillis()/MILLIS_IN_DAY));\r
- }\r
-\r
- DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG, 0, Locale.getDefault());\r
-\r
- logln("\nswitchover in 1582");\r
- cal.set(1582, 9, 4);\r
- logln(fmt.format(cal));\r
- cal.add(Calendar.DATE, 1);\r
- logln(fmt.format(cal));\r
- cal.set(Calendar.JULIAN_DAY, 1721426);\r
- logln(fmt.format(cal));\r
-\r
- logln("\nlate switchover - proleptic Julian");\r
- cal.set(1582, 9, 4);\r
- cal.setGregorianChange(new Date(Long.MAX_VALUE));\r
- logln(fmt.format(cal));\r
- cal.add(Calendar.DATE, 1);\r
- logln(fmt.format(cal));\r
- cal.set(Calendar.JULIAN_DAY, 1721426);\r
- logln(fmt.format(cal));\r
-\r
- logln("\nearly switchover - proleptic Gregorian");\r
- cal.set(1582, 9, 4);\r
- cal.setGregorianChange(new Date(Long.MIN_VALUE));\r
- logln(fmt.format(cal));\r
- cal.add(Calendar.DATE, 1);\r
- logln(fmt.format(cal));\r
- cal.set(Calendar.JULIAN_DAY, 1721426);\r
- logln(fmt.format(cal));\r
- }\r
-}\r
-\r
-//eof\r
+//##header J2SE15
+/**
+ *******************************************************************************
+ * Copyright (C) 2000-2009, International Business Machines Corporation and *
+ * others. All Rights Reserved. *
+ *******************************************************************************
+ */
+package com.ibm.icu.dev.test.calendar;
+import com.ibm.icu.util.*;
+import com.ibm.icu.text.DateFormat;
+
+import java.util.Date;
+import java.util.Locale;
+import java.io.*;
+
+public class CompatibilityTest extends com.ibm.icu.dev.test.TestFmwk {
+
+ public static void main(String argv[]) throws Exception {
+ new CompatibilityTest().run(argv);
+ }
+
+ static final String[] FIELD_NAME = {
+ "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",
+ "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",
+ "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",
+ "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",
+ "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",
+ "JULIAN_DAY", "MILLISECONDS_IN_DAY",
+ };
+
+ /**
+ * Test the behavior of the GregorianCalendar around the changeover.
+ */
+ public void TestGregorianChangeover() {
+
+ java.util.TimeZone jdkGMT = java.util.TimeZone.getTimeZone("GMT");
+ java.util.Calendar jdkCal = java.util.Calendar.getInstance(jdkGMT);
+ jdkCal.clear();
+ jdkCal.set(1582, Calendar.OCTOBER, 15);
+
+// if(jdkCal instanceof java.util.GregorianCalendar) {
+// logln("jdk IS grego");
+// java.util.GregorianCalendar jdkgc = (java.util.GregorianCalendar)
+// jdkCal;
+// logln("jdk change at: " + jdkgc.getGregorianChange() + "(" + jdkgc.getGregorianChange().getTime() +")" );
+// } else {
+// logln("jdk NOT grego");
+// }
+
+ long a = jdkCal.getTime().getTime();
+ Date c = jdkCal.getTime();
+ c.toString();
+ long b = c.getTime();
+ if(a!=b) {
+ logln(" " + a + " != " + b);
+ logln("JDK has Gregorian cutover anomaly (1.5?) - skipping this test.");
+ return;
+ }
+
+ Date co = jdkCal.getTime();
+ logln("Change over (Oct 15 1582) = " + co + " (" + co.getTime() + ")");
+ final int ONE_DAY = 24*60*60*1000;
+ TimeZone gmt = TimeZone.getTimeZone("GMT");
+ GregorianCalendar cal = new GregorianCalendar(gmt);
+ /*
+ Changeover -7 days: 1582/9/28 dow=6
+ Changeover -6 days: 1582/9/29 dow=7
+ Changeover -5 days: 1582/9/30 dow=1
+ Changeover -4 days: 1582/10/1 dow=2
+ Changeover -3 days: 1582/10/2 dow=3
+ Changeover -2 days: 1582/10/3 dow=4
+ Changeover -1 days: 1582/10/4 dow=5
+ Changeover +0 days: 1582/10/15 dow=6
+ Changeover +1 days: 1582/10/16 dow=7
+ Changeover +2 days: 1582/10/17 dow=1
+ Changeover +3 days: 1582/10/18 dow=2
+ Changeover +4 days: 1582/10/19 dow=3
+ Changeover +5 days: 1582/10/20 dow=4
+ Changeover +6 days: 1582/10/21 dow=5
+ Changeover +7 days: 1582/10/22 dow=6
+ */
+ int MON[] = { 9, 9, 9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };
+ int DOM[] = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };
+ int DOW[] = { 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6 };
+ // ^ <-Changeover Fri Oct 15 1582
+ int j=0;
+ for (int i=-7; i<=7; ++i, ++j) {
+ Date d = new Date(co.getTime() + i*ONE_DAY);
+ cal.setTime(d);
+ int y = cal.get(Calendar.YEAR), mon = cal.get(Calendar.MONTH)+1-Calendar.JANUARY,
+ dom = cal.get(Calendar.DATE), dow = cal.get(Calendar.DAY_OF_WEEK);
+ logln("Changeover " + (i>=0?"+":"") +
+ i + " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);
+ if (y != 1582 || mon != MON[j] || dom != DOM[j] || dow != DOW[j])
+ errln(" Fail: Above line is wrong");
+ }
+ }
+
+ /**
+ * Test the mapping between millis and fields. For the purposes
+ * of this test, we don't care about timezones and week data
+ * (first day of week, minimal days in first week).
+ */
+ public void TestMapping() {
+ if (false) {
+ Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);
+ Date PURE_JULIAN = new Date(Long.MAX_VALUE);
+ GregorianCalendar cal =
+ new GregorianCalendar(TimeZone.getTimeZone("UTC"));
+ final int EPOCH_JULIAN = 2440588;
+ final long ONE_DAY = 24*60*60*1000L;
+ com.ibm.icu.text.SimpleDateFormat fmt =
+ new com.ibm.icu.text.SimpleDateFormat("EEE MMM dd yyyy G");
+ /*HH:mm:ss.SSS z*/
+
+ for (int type=0; type<2; ++type) {
+ System.out.println(type==0 ? "Gregorian" : "Julian");
+ cal.setGregorianChange(type==0 ? PURE_GREGORIAN : PURE_JULIAN);
+ fmt.setCalendar(cal);
+ int[] J = {
+ 0x7FFFFFFF,
+ 0x7FFFFFF0,
+ 0x7F000000,
+ 0x78000000,
+ 0x70000000,
+ 0x60000000,
+ 0x50000000,
+ 0x40000000,
+ 0x30000000,
+ 0x20000000,
+ 0x10000000,
+ };
+ for (int i=0; i<J.length; ++i) {
+ String[] lim = new String[2];
+ long[] ms = new long[2];
+ int jd = J[i];
+ for (int sign=0; sign<2; ++sign) {
+ int julian = jd;
+ if (sign==0) julian = -julian;
+ long millis = ((long)julian - EPOCH_JULIAN) * ONE_DAY;
+ ms[sign] = millis;
+ cal.setTime(new Date(millis));
+ lim[sign] = fmt.format(cal.getTime());
+ }
+ System.out.println("JD +/-" +
+ Long.toString(jd, 16) +
+ ": " + ms[0] + ".." + ms[1] +
+ ": " + lim[0] + ".." + lim[1]);
+ }
+ }
+ }
+
+ TimeZone saveZone = TimeZone.getDefault();
+ try {
+ TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+ //NEWCAL
+ Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);
+ Date PURE_JULIAN = new Date(Long.MAX_VALUE);
+ GregorianCalendar cal = new GregorianCalendar();
+ final int EPOCH_JULIAN = 2440588;
+ final long ONE_DAY = 24*60*60*1000L;
+ int[] DATA = {
+ // Julian# Year Month DOM JULIAN:Year, Month, DOM
+ 2440588, 1970, Calendar.JANUARY, 1, 1969, Calendar.DECEMBER, 19,
+ 2415080, 1900, Calendar.MARCH, 1, 1900, Calendar.FEBRUARY, 17,
+ 2451604, 2000, Calendar.FEBRUARY, 29, 2000, Calendar.FEBRUARY, 16,
+ 2452269, 2001, Calendar.DECEMBER, 25, 2001, Calendar.DECEMBER, 12,
+ 2416526, 1904, Calendar.FEBRUARY, 15, 1904, Calendar.FEBRUARY, 2,
+ 2416656, 1904, Calendar.JUNE, 24, 1904, Calendar.JUNE, 11,
+ 1721426, 1, Calendar.JANUARY, 1, 1, Calendar.JANUARY, 3,
+ 2000000, 763, Calendar.SEPTEMBER, 18, 763, Calendar.SEPTEMBER, 14,
+ 4000000, 6239, Calendar.JULY, 12, 6239, Calendar.MAY, 28,
+ 8000000, 17191, Calendar.FEBRUARY, 26, 17190, Calendar.OCTOBER, 22,
+ 10000000, 22666, Calendar.DECEMBER, 20, 22666, Calendar.JULY, 5,
+ };
+ for (int i=0; i<DATA.length; i+=7) {
+ int julian = DATA[i];
+ int year = DATA[i+1];
+ int month = DATA[i+2];
+ int dom = DATA[i+3];
+ int year2, month2, dom2;
+ long millis = (julian - EPOCH_JULIAN) * ONE_DAY;
+ String s;
+
+ // Test Gregorian computation
+ cal.setGregorianChange(PURE_GREGORIAN);
+ cal.clear();
+ cal.set(year, month, dom);
+ long calMillis = cal.getTime().getTime();
+ long delta = calMillis - millis;
+ cal.setTime(new Date(millis));
+ year2 = cal.get(Calendar.YEAR);
+ month2 = cal.get(Calendar.MONTH);
+ dom2 = cal.get(Calendar.DAY_OF_MONTH);
+ s = "G " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +
+ " => " + calMillis +
+ " (" + ((float)delta/ONE_DAY) + " day delta) => " +
+ year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;
+ if (delta != 0 || year != year2 || month != month2 ||
+ dom != dom2) errln(s + " FAIL");
+ else logln(s);
+
+ // Test Julian computation
+ year = DATA[i+4];
+ month = DATA[i+5];
+ dom = DATA[i+6];
+ cal.setGregorianChange(PURE_JULIAN);
+ cal.clear();
+ cal.set(year, month, dom);
+ calMillis = cal.getTime().getTime();
+ delta = calMillis - millis;
+ cal.setTime(new Date(millis));
+ year2 = cal.get(Calendar.YEAR);
+ month2 = cal.get(Calendar.MONTH);
+ dom2 = cal.get(Calendar.DAY_OF_MONTH);
+ s = "J " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +
+ " => " + calMillis +
+ " (" + ((float)delta/ONE_DAY) + " day delta) => " +
+ year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;
+ if (delta != 0 || year != year2 || month != month2 ||
+ dom != dom2) errln(s + " FAIL");
+ else logln(s);
+ }
+
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1582, Calendar.OCTOBER, 15);
+ cal.setGregorianChange(tempcal.getTime());
+ auxMapping(cal, 1582, Calendar.OCTOBER, 4);
+ auxMapping(cal, 1582, Calendar.OCTOBER, 15);
+ auxMapping(cal, 1582, Calendar.OCTOBER, 16);
+ for (int y=800; y<3000; y+=1+(int)(100*Math.random())) {
+ for (int m=Calendar.JANUARY; m<=Calendar.DECEMBER; ++m) {
+ auxMapping(cal, y, m, 15);
+ }
+ }
+ }
+ finally {
+ TimeZone.setDefault(saveZone);
+ }
+ }
+ private void auxMapping(Calendar cal, int y, int m, int d) {
+ cal.clear();
+ cal.set(y, m, d);
+ long millis = cal.getTime().getTime();
+ cal.setTime(new Date(millis));
+ int year2 = cal.get(Calendar.YEAR);
+ int month2 = cal.get(Calendar.MONTH);
+ int dom2 = cal.get(Calendar.DAY_OF_MONTH);
+ if (y != year2 || m != month2 || dom2 != d)
+ errln("Round-trip failure: " + y + "-" + (m+1) + "-"+d+" =>ms=> " +
+ year2 + "-" + (month2+1) + "-" + dom2);
+ }
+
+ public void TestGenericAPI() {
+ // not used String str;
+
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1990, Calendar.APRIL, 15);
+ Date when = tempcal.getTime();
+
+ String tzid = "TestZone";
+ int tzoffset = 123400;
+
+ SimpleTimeZone zone = new SimpleTimeZone(tzoffset, tzid);
+ Calendar cal = (Calendar)Calendar.getInstance((SimpleTimeZone)zone.clone());
+
+ if (!zone.equals(cal.getTimeZone())) errln("FAIL: Calendar.getTimeZone failed");
+
+ Calendar cal2 = Calendar.getInstance(cal.getTimeZone());
+
+ cal.setTime(when);
+ cal2.setTime(when);
+
+ if (!(cal.equals(cal2))) errln("FAIL: Calendar.operator== failed");
+ // if ((*cal != *cal2)) errln("FAIL: Calendar.operator!= failed");
+ if (!cal.equals(cal2) ||
+ cal.before(cal2) ||
+ cal.after(cal2)) errln("FAIL: equals/before/after failed");
+
+ cal2.setTime(new Date(when.getTime() + 1000));
+ if (cal.equals(cal2) ||
+ cal2.before(cal) ||
+ cal.after(cal2)) errln("FAIL: equals/before/after failed");
+
+ cal.roll(Calendar.SECOND, true);
+ if (!cal.equals(cal2) ||
+ cal.before(cal2) ||
+ cal.after(cal2)) errln("FAIL: equals/before/after failed");
+
+ // Roll back to January
+ cal.roll(Calendar.MONTH, (int)(1 + Calendar.DECEMBER - cal.get(Calendar.MONTH)));
+ if (cal.equals(cal2) ||
+ cal2.before(cal) ||
+ cal.after(cal2)) errln("FAIL: equals/before/after failed");
+
+ // C++ only
+ /* TimeZone z = cal.orphanTimeZone();
+ if (z.getID(str) != tzid ||
+ z.getRawOffset() != tzoffset)
+ errln("FAIL: orphanTimeZone failed");
+ */
+
+ for (int i=0; i<2; ++i) {
+ boolean lenient = ( i > 0 );
+ cal.setLenient(lenient);
+ if (lenient != cal.isLenient()) errln("FAIL: setLenient/isLenient failed");
+ // Later: Check for lenient behavior
+ }
+
+ int i;
+ for (i=Calendar.SUNDAY; i<=Calendar.SATURDAY; ++i) {
+ cal.setFirstDayOfWeek(i);
+ if (cal.getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
+ }
+
+ for (i=1; i<=7; ++i) {
+ cal.setMinimalDaysInFirstWeek(i);
+ if (cal.getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
+ }
+
+ for (i=0; i<cal.getFieldCount(); ++i) {
+ if (cal.getMinimum(i) > cal.getGreatestMinimum(i))
+ errln("FAIL: getMinimum larger than getGreatestMinimum for field " + i);
+ if (cal.getLeastMaximum(i) > cal.getMaximum(i))
+ errln("FAIL: getLeastMaximum larger than getMaximum for field " + i);
+ if (cal.getMinimum(i) >= cal.getMaximum(i))
+ errln("FAIL: getMinimum not less than getMaximum for field " + i);
+ }
+
+ cal.setTimeZone(TimeZone.getDefault());
+ cal.clear();
+ cal.set(1984, 5, 24);
+ tempcal.clear();
+ tempcal.set(1984, 5, 24);
+ if (cal.getTime().getTime() != tempcal.getTime().getTime()) {
+ errln("FAIL: Calendar.set(3 args) failed");
+ logln(" Got: " + cal.getTime() + " Expected: " + tempcal.getTime());
+ }
+
+//#if defined(FOUNDATION10) || defined(J2SE13)
+//## // This test case does not work well with JRE1.3 with
+//## // the timezone update for US 2007 rule. Java 1.3 only
+//## // supports single DST rule for all years. April 2, 1985
+//## // was actually not in DST, but with the new rule, the date
+//## // is in DST (which is actually wrong).
+//#else
+ cal.clear();
+ cal.set(1985, 2, 2, 11, 49);
+ tempcal.clear();
+ tempcal.set(1985, 2, 2, 11, 49);
+ if (cal.getTime().getTime() != tempcal.getTime().getTime()) {
+ errln("FAIL: Calendar.set(5 args) failed");
+ logln(" Got: " + cal.getTime() + " Expected: " + tempcal.getTime());
+ }
+//#endif
+
+ cal.clear();
+ cal.set(1995, 9, 12, 1, 39, 55);
+ tempcal.clear();
+ tempcal.set(1995, 9, 12, 1, 39, 55);
+ if (cal.getTime().getTime() != tempcal.getTime().getTime()) {
+ errln("FAIL: Calendar.set(6 args) failed");
+ logln(" Got: " + cal.getTime() + " Expected: " + tempcal.getTime());
+ }
+
+ cal.getTime();
+ // This test is strange -- why do we expect certain fields to be set, and
+ // others not to be? Revisit the appropriateness of this. - Alan NEWCAL
+ for (i=0; i<cal.getFieldCount(); ++i) {
+ switch(i) {
+ case Calendar.YEAR: case Calendar.MONTH: case Calendar.DATE:
+ case Calendar.HOUR_OF_DAY: case Calendar.MINUTE: case Calendar.SECOND:
+ case Calendar.EXTENDED_YEAR:
+ if (!cal.isSet(i)) errln("FAIL: " + FIELD_NAME[i] + " is not set");
+ break;
+ default:
+ if (cal.isSet(i)) errln("FAIL: " + FIELD_NAME[i] + " is set");
+ }
+ cal.clear(i);
+ if (cal.isSet(i)) errln("FAIL: Calendar.clear/isSet failed");
+ }
+
+ // delete cal;
+ // delete cal2;
+
+ Locale[] loc = Calendar.getAvailableLocales();
+ long count = loc.length;
+ if (count < 1 || loc == null) {
+ errln("FAIL: getAvailableLocales failed");
+ }
+ else {
+ for (i=0; i<count; ++i) {
+ cal = Calendar.getInstance(loc[i]);
+ // delete cal;
+ }
+ }
+
+ cal = Calendar.getInstance(TimeZone.getDefault(), Locale.ENGLISH);
+ // delete cal;
+
+ cal = Calendar.getInstance(zone, Locale.ENGLISH);
+ // delete cal;
+
+ GregorianCalendar gc = new GregorianCalendar(zone);
+ // delete gc;
+
+ gc = new GregorianCalendar(Locale.ENGLISH);
+ // delete gc;
+
+ gc = new GregorianCalendar(Locale.ENGLISH);
+ // delete gc;
+
+ gc = new GregorianCalendar(zone, Locale.ENGLISH);
+ // delete gc;
+
+ gc = new GregorianCalendar(zone);
+ // delete gc;
+
+ gc = new GregorianCalendar(1998, 10, 14, 21, 43);
+ tempcal.clear();
+ tempcal.set(1998, 10, 14, 21, 43);
+ if (gc.getTime().getTime() != tempcal.getTime().getTime())
+ errln("FAIL: new GregorianCalendar(ymdhm) failed");
+ // delete gc;
+
+ gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55);
+ tempcal.clear();
+ tempcal.set(1998, 10, 14, 21, 43, 55);
+ if (gc.getTime().getTime() != tempcal.getTime().getTime())
+ errln("FAIL: new GregorianCalendar(ymdhms) failed");
+
+ // C++ only:
+ // GregorianCalendar gc2 = new GregorianCalendar(Locale.ENGLISH);
+ // gc2 = gc;
+ // if (gc2 != gc || !(gc2 == gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");
+ // delete gc;
+ // delete z;
+ }
+
+ // Verify Roger Webster's bug
+ public void TestRog() {
+ GregorianCalendar gc = new GregorianCalendar();
+
+ int year = 1997, month = Calendar.APRIL, date = 1;
+ gc.set(year, month, date); // April 1, 1997
+
+ gc.set(Calendar.HOUR_OF_DAY, 23);
+ gc.set(Calendar.MINUTE, 0);
+ gc.set(Calendar.SECOND, 0);
+ gc.set(Calendar.MILLISECOND, 0);
+
+ for (int i = 0; i < 9; i++, gc.add(Calendar.DATE, 1)) {
+ if (gc.get(Calendar.YEAR) != year ||
+ gc.get(Calendar.MONTH) != month ||
+ gc.get(Calendar.DATE) != (date + i))
+ errln("FAIL: Date " + gc.getTime() + " wrong");
+ }
+ }
+
+ // Verify DAY_OF_WEEK
+ public void TestDOW943() {
+ dowTest(false);
+ dowTest(true);
+ }
+
+ void dowTest(boolean lenient) {
+ GregorianCalendar cal = new GregorianCalendar();
+ cal.set(1997, Calendar.AUGUST, 12); // Wednesday
+ cal.getTime(); // Force update
+ cal.setLenient(lenient);
+ cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1, 1996
+ int dow = cal.get(Calendar.DAY_OF_WEEK);
+ int min = cal.getMinimum(Calendar.DAY_OF_WEEK);
+ int max = cal.getMaximum(Calendar.DAY_OF_WEEK);
+ if (dow < min || dow > max) errln("FAIL: Day of week " + dow + " out of range");
+ if (dow != Calendar.SUNDAY) {
+ errln("FAIL2: Day of week should be SUNDAY; is " + dow + ": " + cal.getTime());
+ }
+ if (min != Calendar.SUNDAY || max != Calendar.SATURDAY) errln("FAIL: Min/max bad");
+ }
+
+ // Verify that the clone method produces distinct objects with no
+ // unintentionally shared fields.
+ public void TestClonesUnique908() {
+ Calendar c = Calendar.getInstance();
+ Calendar d = (Calendar)c.clone();
+ c.set(Calendar.MILLISECOND, 123);
+ d.set(Calendar.MILLISECOND, 456);
+ if (c.get(Calendar.MILLISECOND) != 123 ||
+ d.get(Calendar.MILLISECOND) != 456) {
+ errln("FAIL: Clones share fields");
+ }
+ }
+
+ // Verify effect of Gregorian cutoff value
+ public void TestGregorianChange768() {
+ boolean b;
+ GregorianCalendar c = new GregorianCalendar();
+ logln("With cutoff " + c.getGregorianChange());
+ logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));
+ logln(" (should be FALSE)");
+ if (b != false) errln("FAIL");
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1900, 0, 1);
+ c.setGregorianChange(tempcal.getTime()); // Jan 1 1900
+ logln("With cutoff " + c.getGregorianChange());
+ logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));
+ logln(" (should be TRUE)");
+ if (b != true) errln("FAIL");
+ }
+
+ // Test the correct behavior of the disambiguation algorithm.
+ public void TestDisambiguation765() throws Exception {
+ Calendar c = Calendar.getInstance();
+ c.setLenient(false);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.DATE, 3);
+
+ verify765("1997 third day of June = ", c, 1997, Calendar.JUNE, 3);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
+ verify765("1997 first Tuesday in June = ", c, 1997, Calendar.JUNE, 3);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);
+ verify765("1997 last Tuesday in June = ", c, 1997, Calendar.JUNE, 24);
+
+ IllegalArgumentException e = null;
+ try {
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 0);
+ c.getTime();
+ }
+ catch (IllegalArgumentException ex) {
+ e = ex;
+ }
+ verify765("1997 zero-th Tuesday in June = ", e, c);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.WEEK_OF_MONTH, 1);
+ verify765("1997 Tuesday in week 1 of June = ", c, 1997, Calendar.JUNE, 3);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.WEEK_OF_MONTH, 5);
+ verify765("1997 Tuesday in week 5 of June = ", c, 1997, Calendar.JULY, 1);
+
+ try {
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.MONTH, Calendar.JUNE);
+ c.set(Calendar.WEEK_OF_MONTH, 0);
+ c.getTime();
+ }
+ catch (IllegalArgumentException ex) {
+ e = ex;
+ }
+ verify765("1997 Tuesday in week 0 of June = ", e, c);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.WEEK_OF_YEAR, 1);
+ verify765("1997 Tuesday in week 1 of year = ", c, 1996, Calendar.DECEMBER, 31);
+
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.WEEK_OF_YEAR, 10);
+ verify765("1997 Tuesday in week 10 of year = ", c, 1997, Calendar.MARCH, 4);
+
+ e = null;
+ try {
+ c.clear();
+ c.set(Calendar.YEAR, 1997);
+ c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
+ c.set(Calendar.WEEK_OF_YEAR, 0);
+ c.getTime();
+ }
+ catch (IllegalArgumentException ex) {
+ e = ex;
+ }
+ verify765("1997 Tuesday in week 0 of year = ", e, c);
+ }
+ void verify765(String msg, Calendar c, int year, int month, int day) {
+ int cy = c.get(Calendar.YEAR); // NEWCAL
+ int cm = c.get(Calendar.MONTH);
+ int cd = c.get(Calendar.DATE);
+ if (cy == year &&
+ cm == month &&
+ cd == day) {
+ logln("PASS: " + msg + c.getTime());
+ }
+ else {
+ errln("FAIL: " + msg + cy + "/" + (cm+1) + "/" + cd +
+ "=" + c.getTime() +
+ "; expected " +
+ year + "/" + (month+1) + "/" + day);
+ }
+ }
+ // Called when e expected to be non-null
+ void verify765(String msg, IllegalArgumentException e, Calendar c) {
+ if (e == null) errln("FAIL: No IllegalArgumentException for " + msg +
+ c.getTime());
+ else logln("PASS: " + msg + "IllegalArgument as expected");
+ }
+
+ // Test the behavior of GMT vs. local time
+ public void TestGMTvsLocal4064654() {
+ // Sample output 1:
+ // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 1 1 12 0 0
+ // date = Wed Jan 01 04:00:00 PST 1997
+ // offset for Wed Jan 01 04:00:00 PST 1997= -8hr
+ aux4064654(1997, 1, 1, 12, 0, 0);
+
+ // Sample output 2:
+ // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 4 16 18 30 0
+ // date = Wed Apr 16 10:30:00 PDT 1997
+ // offset for Wed Apr 16 10:30:00 PDT 1997= -7hr
+
+ // Note that in sample output 2 according to the offset, the gmt time
+ // of the result would be 1997 4 16 17 30 0 which is different from the
+ // input of 1997 4 16 18 30 0.
+ aux4064654(1997, 4, 16, 18, 30, 0);
+ }
+ void aux4064654(int yr, int mo, int dt, int hr, int mn, int sc) {
+ Date date;
+ Calendar gmtcal = Calendar.getInstance();
+ gmtcal.setTimeZone(TimeZone.getTimeZone("Africa/Casablanca"));
+ gmtcal.set(yr, mo-1, dt, hr, mn, sc);
+ gmtcal.set(Calendar.MILLISECOND, 0);
+
+ date = gmtcal.getTime();
+ logln("date = "+date);
+
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeZone(TimeZone.getTimeZone("America/Los_Angels"));
+ cal.setTime(date);
+
+ int offset = cal.getTimeZone().getOffset(cal.get(Calendar.ERA),
+ cal.get(Calendar.YEAR),
+ cal.get(Calendar.MONTH),
+ cal.get(Calendar.DATE),
+ cal.get(Calendar.DAY_OF_WEEK),
+ cal.get(Calendar.MILLISECOND));
+
+ logln("offset for "+date+"= "+(offset/1000/60/60.0) + "hr");
+
+ int utc = ((cal.get(Calendar.HOUR_OF_DAY) * 60 +
+ cal.get(Calendar.MINUTE)) * 60 +
+ cal.get(Calendar.SECOND)) * 1000 +
+ cal.get(Calendar.MILLISECOND) - offset;
+
+ int expected = ((hr * 60 + mn) * 60 + sc) * 1000;
+
+ if (utc != expected)
+ errln("FAIL: Discrepancy of " +
+ (utc - expected) + " millis = " +
+ ((utc-expected)/1000/60/60.0) + " hr");
+ }
+
+ // Verify that add and set work regardless of the order in which
+ // they are called.
+ public void TestAddSetOrder621() {
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1997, 4, 14, 13, 23, 45);
+ Date d = tempcal.getTime();
+
+ Calendar cal = Calendar.getInstance ();
+ cal.setTime (d);
+ cal.add (Calendar.DATE, -5);
+ cal.set (Calendar.HOUR_OF_DAY, 0);
+ cal.set (Calendar.MINUTE, 0);
+ cal.set (Calendar.SECOND, 0);
+ // ma feb 03 00:00:00 GMT+00:00 1997
+ String s = cal.getTime ().toString ();
+
+ cal = Calendar.getInstance ();
+ cal.setTime (d);
+ cal.set (Calendar.HOUR_OF_DAY, 0);
+ cal.set (Calendar.MINUTE, 0);
+ cal.set (Calendar.SECOND, 0);
+ cal.add (Calendar.DATE, -5);
+ // ma feb 03 13:11:06 GMT+00:00 1997
+ String s2 = cal.getTime ().toString ();
+
+ if (s.equals(s2))
+ logln("Pass: " + s + " == " + s2);
+ else
+ errln("FAIL: " + s + " != " + s2);
+ }
+
+ // Verify that add works.
+ public void TestAdd520() {
+ int y = 1997, m = Calendar.FEBRUARY, d = 1;
+ GregorianCalendar temp = new GregorianCalendar( y, m, d );
+ check520(temp, y, m, d);
+
+ temp.add( Calendar.YEAR, 1 );
+ y++;
+ check520(temp, y, m, d);
+
+ temp.add( Calendar.MONTH, 1 );
+ m++;
+ check520(temp, y, m, d);
+
+ temp.add( Calendar.DATE, 1 );
+ d++;
+ check520(temp, y, m, d);
+
+ temp.add( Calendar.DATE, 2 );
+ d += 2;
+ check520(temp, y, m, d);
+
+ temp.add( Calendar.DATE, 28 );
+ d = 1; ++m;
+ check520(temp, y, m, d);
+ }
+ void check520(Calendar c, int y, int m, int d) {
+ if (c.get(Calendar.YEAR) != y ||
+ c.get(Calendar.MONTH) != m ||
+ c.get(Calendar.DATE) != d) {
+ errln("FAILURE: Expected YEAR/MONTH/DATE of " +
+ y + "/" + (m+1) + "/" + d +
+ "; got " +
+ c.get(Calendar.YEAR) + "/" +
+ (c.get(Calendar.MONTH)+1) + "/" +
+ c.get(Calendar.DATE));
+ }
+ else logln("Confirmed: " +
+ y + "/" + (m+1) + "/" + d);
+ }
+
+ // Verify that setting fields works. This test fails when an exception is thrown.
+ public void TestFieldSet4781() {
+ try {
+ GregorianCalendar g = new GregorianCalendar();
+ GregorianCalendar g2 = new GregorianCalendar();
+ // At this point UTC value is set, various fields are not.
+ // Now set to noon.
+ g2.set(Calendar.HOUR, 12);
+ g2.set(Calendar.MINUTE, 0);
+ g2.set(Calendar.SECOND, 0);
+ // At this point the object thinks UTC is NOT set, but fields are set.
+ // The following line will result in IllegalArgumentException because
+ // it thinks the YEAR is set and it is NOT.
+ if (g2.equals(g))
+ logln("Same");
+ else
+ logln("Different");
+ }
+ catch (IllegalArgumentException e) {
+ errln("Unexpected exception seen: " + e);
+ }
+ }
+
+ // Test serialization of a Calendar object
+ public void TestSerialize337() {
+ Calendar cal = Calendar.getInstance();
+
+ boolean ok = false;
+
+ try {
+ ByteArrayOutputStream f = new ByteArrayOutputStream();
+ ObjectOutput s = new ObjectOutputStream(f);
+ s.writeObject(PREFIX);
+ s.writeObject(cal);
+ s.writeObject(POSTFIX);
+ f.close();
+
+ ByteArrayInputStream in = new ByteArrayInputStream(f.toByteArray());
+ ObjectInputStream t = new ObjectInputStream(in);
+ String pre = (String)t.readObject();
+ Calendar c = (Calendar)t.readObject();
+ String post = (String)t.readObject();
+ in.close();
+
+ ok = pre.equals(PREFIX) &&
+ post.equals(POSTFIX) &&
+ cal.equals(c);
+ }
+ catch (IOException e) {
+ errln("FAIL: Exception received:");
+ // e.printStackTrace(log);
+ }
+ catch (ClassNotFoundException e) {
+ errln("FAIL: Exception received:");
+ // e.printStackTrace(log);
+ }
+
+ if (!ok) errln("Serialization of Calendar object failed.");
+ }
+ static final String PREFIX = "abc";
+ static final String POSTFIX = "def";
+ static final String FILENAME = "tmp337.bin";
+
+ // Try to zero out the seconds field
+ public void TestSecondsZero121() {
+ Calendar cal = new GregorianCalendar();
+ // Initialize with current date/time
+ cal.setTime(new Date());
+ // Round down to minute
+ cal.set(Calendar.SECOND, 0);
+ Date d = cal.getTime();
+ String s = d.toString();
+ if (s.indexOf(":00 ") < 0) errln("Expected to see :00 in " + s);
+ }
+
+ // Try various sequences of add, set, and get method calls.
+ public void TestAddSetGet0610() {
+ //
+ // Error case 1:
+ // - Upon initialization calendar fields, millis = System.currentTime
+ // - After set is called fields are initialized, time is not
+ // - Addition uses millis which are still *now*
+ //
+ {
+ Calendar calendar = new GregorianCalendar( ) ;
+ calendar.set( 1993, Calendar.JANUARY, 4 ) ;
+ logln( "1A) " + value( calendar ) ) ;
+ calendar.add( Calendar.DATE, 1 ) ;
+ String v = value(calendar);
+ logln( "1B) " + v );
+ logln( "--) 1993/0/5" ) ;
+ if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
+ "; saw " + v);
+ }
+
+ //
+ // Error case 2:
+ // - Upon initialization calendar fields set, millis = 0
+ // - Addition uses millis which are still 1970, 0, 1
+ //
+
+ {
+ Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;
+ logln( "2A) " + value( calendar ) ) ;
+ calendar.add( Calendar.DATE, 1 ) ;
+ String v = value(calendar);
+ logln( "2B) " + v );
+ logln( "--) 1993/0/5" ) ;
+ if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
+ "; saw " + v);
+ }
+
+ //
+ // Error case 3:
+ // - Upon initialization calendar fields, millis = 0
+ // - getTime( ) is called which forces the millis to be set
+ // - Addition uses millis which are correct
+ //
+
+ {
+ Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;
+ logln( "3A) " + value( calendar ) ) ;
+ calendar.getTime( ) ;
+ calendar.add( Calendar.DATE, 1 ) ;
+ String v = value(calendar);
+ logln( "3B) " + v ) ;
+ logln( "--) 1993/0/5" ) ;
+ if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
+ "; saw " + v);
+ }
+ }
+ static String value( Calendar calendar ) {
+ return( calendar.get( Calendar.YEAR ) + "/" +
+ calendar.get( Calendar.MONTH ) + "/" +
+ calendar.get( Calendar.DATE ) ) ;
+ }
+ static String EXPECTED_0610 = "1993/0/5";
+
+ // Test that certain fields on a certain date are as expected.
+ public void TestFields060() {
+ int year = 1997;
+ int month = java.util.Calendar.OCTOBER; //october
+ int dDate = 22; //DAYOFWEEK should return 3 for Wednesday
+ GregorianCalendar calendar = null;
+
+ calendar = new GregorianCalendar( year, month, dDate);
+ for (int i=0; i<EXPECTED_FIELDS.length; ) {
+ int field = EXPECTED_FIELDS[i++];
+ int expected = EXPECTED_FIELDS[i++];
+ if (calendar.get(field) != expected) {
+ errln("Expected field " + field + " to have value " + expected +
+ "; received " + calendar.get(field) + " instead");
+ }
+ }
+ }
+ static int EXPECTED_FIELDS[] = {
+ Calendar.YEAR, 1997,
+ Calendar.MONTH, Calendar.OCTOBER,
+ Calendar.DAY_OF_MONTH, 22,
+ Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY,
+ Calendar.DAY_OF_WEEK_IN_MONTH, 4,
+ Calendar.DAY_OF_YEAR, 295
+ };
+
+ // Verify that the fields are as expected (mostly zero) at the epoch start.
+ // Note that we adjust for the default timezone to get most things to zero.
+ public void TestEpochStartFields() {
+ TimeZone z = TimeZone.getDefault();
+ Calendar c = Calendar.getInstance();
+ Date d = new Date(-z.getRawOffset());
+ if (z.inDaylightTime(d)) {
+ logln("Warning: Skipping test because " + d +
+ " is in DST.");
+ }
+ else {
+ c.setTime(d);
+ c.setMinimalDaysInFirstWeek(1);
+ for (int i=0; i<Calendar.ZONE_OFFSET; ++i) {
+ if (c.get(i) != EPOCH_FIELDS[i])
+ errln("Expected field " + i + " to have value " + EPOCH_FIELDS[i] +
+ "; saw " + c.get(i) + " instead");
+ }
+ if (c.get(Calendar.ZONE_OFFSET) != z.getRawOffset())
+ errln("Expected field ZONE_OFFSET to have value " + z.getRawOffset() +
+ "; saw " + c.get(Calendar.ZONE_OFFSET) + " instead");
+ if (c.get(Calendar.DST_OFFSET) != 0)
+ errln("Expected field DST_OFFSET to have value 0" +
+ "; saw " + c.get(Calendar.DST_OFFSET) + " instead");
+ }
+ }
+ // These are the fields at the epoch start
+ static int EPOCH_FIELDS[] = { 1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0 };
+
+ // Verify that as you add days to the calendar (e.g., 24 day periods),
+ // the day of the week shifts in the expected pattern.
+ public void TestDOWProgression() {
+ Calendar cal =
+ new GregorianCalendar(1972, Calendar.OCTOBER, 26);
+ marchByDelta(cal, 24); // Last parameter must be != 0 modulo 7
+ }
+
+ // Supply a delta which is not a multiple of 7.
+ void marchByDelta(Calendar cal, int delta) {
+ Calendar cur = (Calendar)cal.clone();
+ int initialDOW = cur.get(Calendar.DAY_OF_WEEK);
+ int DOW, newDOW = initialDOW;
+ do {
+ DOW = newDOW;
+ logln("DOW = " + DOW + " " + cur.getTime());
+
+ cur.add(Calendar.DAY_OF_WEEK, delta);
+ newDOW = cur.get(Calendar.DAY_OF_WEEK);
+ int expectedDOW = 1 + (DOW + delta - 1) % 7;
+ if (newDOW != expectedDOW) {
+ errln("Day of week should be " + expectedDOW +
+ " instead of " + newDOW + " on " + cur.getTime());
+ return;
+ }
+ }
+ while (newDOW != initialDOW);
+ }
+
+ public void TestActualMinMax() {
+ Calendar cal = new GregorianCalendar(1967, Calendar.MARCH, 10);
+ cal.setFirstDayOfWeek(Calendar.SUNDAY);
+ cal.setMinimalDaysInFirstWeek(3);
+
+ if (cal.getActualMinimum(Calendar.DAY_OF_MONTH) != 1)
+ errln("Actual minimum date for 3/10/1967 should have been 1; got " +
+ cal.getActualMinimum(Calendar.DAY_OF_MONTH));
+ if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 31)
+ errln("Actual maximum date for 3/10/1967 should have been 31; got " +
+ cal.getActualMaximum(Calendar.DAY_OF_MONTH));
+
+ cal.set(Calendar.MONTH, Calendar.FEBRUARY);
+ if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 28)
+ errln("Actual maximum date for 2/10/1967 should have been 28; got " +
+ cal.getActualMaximum(Calendar.DAY_OF_MONTH));
+ if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 365)
+ errln("Number of days in 1967 should have been 365; got " +
+ cal.getActualMaximum(Calendar.DAY_OF_YEAR));
+
+ cal.set(Calendar.YEAR, 1968);
+ if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 29)
+ errln("Actual maximum date for 2/10/1968 should have been 29; got " +
+ cal.getActualMaximum(Calendar.DAY_OF_MONTH));
+ if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 366)
+ errln("Number of days in 1968 should have been 366; got " +
+ cal.getActualMaximum(Calendar.DAY_OF_YEAR));
+ // Using week settings of SUNDAY/3 (see above)
+ if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 52)
+ errln("Number of weeks in 1968 should have been 52; got " +
+ cal.getActualMaximum(Calendar.WEEK_OF_YEAR));
+
+ cal.set(Calendar.YEAR, 1976);
+ cal.set(Calendar.DAY_OF_WEEK, cal.getFirstDayOfWeek()); // Added - Liu 11/6/00
+ // Using week settings of SUNDAY/3 (see above)
+ if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 53)
+ errln("Number of weeks in 1976 should have been 53; got " +
+ cal.getActualMaximum(Calendar.WEEK_OF_YEAR));
+ }
+
+ public void TestRoll() {
+ Calendar cal = new GregorianCalendar(1997, Calendar.JANUARY, 31);
+
+ int[] dayValues = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 };
+ for (int i = 0; i < dayValues.length; i++) {
+ Calendar cal2 = (Calendar)cal.clone();
+ cal2.roll(Calendar.MONTH, i);
+ if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues[i])
+ errln("Rolling the month in 1/31/1997 up by " + i + " should have yielded "
+ + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "
+ + ((i + 1) % 12) + "/" + cal2.get(Calendar.DAY_OF_MONTH) + "/1997.");
+ }
+
+ cal.set(1996, Calendar.FEBRUARY, 29);
+
+ //int[] monthValues = { 1, 2, 2, 2, 1, 2, 2, 2, 1, 2 };
+ //int[] dayValues2 = { 29, 1, 1, 1, 29, 1, 1, 1, 29, 1 };
+
+ // I've revised the expected values to make more sense -- rolling
+ // the year should pin the DAY_OF_MONTH. - Liu 11/6/00
+ int[] monthValues = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+ int[] dayValues2 = { 29, 28, 28, 28, 29, 28, 28, 28, 29, 28 };
+
+ for (int i = 0; i < dayValues2.length; i++) {
+ Calendar cal2 = (Calendar)cal.clone();
+ cal2.roll(Calendar.YEAR, i);
+ if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues2[i] || cal2.get(Calendar.MONTH)
+ != monthValues[i])
+ errln("Roll 2/29/1996 by " + i + " year: expected "
+ + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"
+ + (1996 + i) + ", got "
+ + (cal2.get(Calendar.MONTH) + 1) + "/" +
+ cal2.get(Calendar.DAY_OF_MONTH) + "/" + cal2.get(Calendar.YEAR));
+ }
+
+ // Test rolling hour of day
+ cal.set(Calendar.HOUR_OF_DAY, 0);
+ cal.roll(Calendar.HOUR_OF_DAY, -2);
+ int f = cal.get(Calendar.HOUR_OF_DAY);
+ if (f != 22) errln("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");
+ cal.roll(Calendar.HOUR_OF_DAY, 5);
+ f = cal.get(Calendar.HOUR_OF_DAY);
+ if (f != 3) errln("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");
+ cal.roll(Calendar.HOUR_OF_DAY, 21);
+ f = cal.get(Calendar.HOUR_OF_DAY);
+ if (f != 0) errln("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");
+
+ // Test rolling hour
+ cal.set(Calendar.HOUR_OF_DAY, 0);
+ cal.roll(Calendar.HOUR, -2);
+ f = cal.get(Calendar.HOUR);
+ if (f != 10) errln("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");
+ cal.roll(Calendar.HOUR, 5);
+ f = cal.get(Calendar.HOUR);
+ if (f != 3) errln("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");
+ cal.roll(Calendar.HOUR, 9);
+ f = cal.get(Calendar.HOUR);
+ if (f != 0) errln("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");
+ }
+
+ public void TestComputeJulianDay4406() {
+ // jb4406 is probably not a bug, this is to document the behavior
+ GregorianCalendar cal = new GregorianCalendar();
+ final int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
+
+ logln("julian day value jumps at changeover");
+ for (int day = 12; day < 18; ++day) {
+ cal.set(1582, 9, day);
+ logln("[" + day + "] " + (cal.getTimeInMillis()/MILLIS_IN_DAY));
+ }
+
+ logln("\njulian days not accurate before 1 March 0004");
+ for (int day = 1; day < 3; ++day) {
+ cal.set(1, 0, day);
+ logln("[" + day + "] " + (cal.getTimeInMillis()/MILLIS_IN_DAY));
+ }
+
+ DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG, 0, Locale.getDefault());
+
+ logln("\nswitchover in 1582");
+ cal.set(1582, 9, 4);
+ logln(fmt.format(cal));
+ cal.add(Calendar.DATE, 1);
+ logln(fmt.format(cal));
+ cal.set(Calendar.JULIAN_DAY, 1721426);
+ logln(fmt.format(cal));
+
+ logln("\nlate switchover - proleptic Julian");
+ cal.set(1582, 9, 4);
+ cal.setGregorianChange(new Date(Long.MAX_VALUE));
+ logln(fmt.format(cal));
+ cal.add(Calendar.DATE, 1);
+ logln(fmt.format(cal));
+ cal.set(Calendar.JULIAN_DAY, 1721426);
+ logln(fmt.format(cal));
+
+ logln("\nearly switchover - proleptic Gregorian");
+ cal.set(1582, 9, 4);
+ cal.setGregorianChange(new Date(Long.MIN_VALUE));
+ logln(fmt.format(cal));
+ cal.add(Calendar.DATE, 1);
+ logln(fmt.format(cal));
+ cal.set(Calendar.JULIAN_DAY, 1721426);
+ logln(fmt.format(cal));
+ }
+}
+
+//eof
projects / Dictionary.git / blobdiff