-//##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 java.io.ByteArrayInputStream;\r
-import java.io.ByteArrayOutputStream;\r
-import java.io.IOException;\r
-import java.io.ObjectInputStream;\r
-import java.io.ObjectOutputStream;\r
-import java.util.Date;\r
-import java.util.HashSet;\r
-import java.util.Locale;\r
-import java.util.MissingResourceException;\r
-\r
-import com.ibm.icu.impl.Utility;\r
-import com.ibm.icu.text.DateFormat;\r
-import com.ibm.icu.text.NumberFormat;\r
-import com.ibm.icu.text.SimpleDateFormat;\r
-import com.ibm.icu.util.Calendar;\r
-import com.ibm.icu.util.GregorianCalendar;\r
-import com.ibm.icu.util.SimpleTimeZone;\r
-import com.ibm.icu.util.TimeZone;\r
-import com.ibm.icu.util.ULocale;\r
-\r
-/**\r
- * @test 1.32 99/11/14\r
- * @bug 4031502 4035301 4040996 4051765 4059654 4061476 4070502 4071197 4071385\r
- * 4073929 4083167 4086724 4092362 4095407 4096231 4096539 4100311 4103271\r
- * 4106136 4108764 4114578 4118384 4125881 4125892 4136399 4141665 4142933\r
- * 4145158 4145983 4147269 4149677 4162587 4165343 4166109 4167060 4173516\r
- * 4174361 4177484 4197699 4209071 4288792\r
- */\r
-public class CalendarRegression extends com.ibm.icu.dev.test.TestFmwk {\r
-\r
- public static void main(String[] args) throws Exception {\r
- new CalendarRegression().run(args);\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
- /*\r
- Synopsis: java.sql.Timestamp constructor works wrong on Windows 95\r
-\r
- ==== Here is the test ==== \r
- public static void main (String args[]) { \r
- java.sql.Timestamp t= new java.sql.Timestamp(0,15,5,5,8,13,123456700); \r
- logln("expected=1901-04-05 05:08:13.1234567"); \r
- logln(" result="+t); \r
- } \r
- \r
- ==== Here is the output of the test on Solaris or NT ==== \r
- expected=1901-04-05 05:08:13.1234567 \r
- result=1901-04-05 05:08:13.1234567 \r
- \r
- ==== Here is the output of the test on Windows95 ==== \r
- expected=1901-04-05 05:08:13.1234567 \r
- result=1901-04-05 06:08:13.1234567 \r
- */\r
-\r
- public void Test4031502() {\r
- try{\r
- // This bug actually occurs on Windows NT as well, and doesn't\r
- // require the host zone to be set; it can be set in Java.\r
- String[] ids = TimeZone.getAvailableIDs();\r
- boolean bad = false;\r
- for (int i=0; i<ids.length; ++i) {\r
- TimeZone zone = TimeZone.getTimeZone(ids[i]);\r
- GregorianCalendar cal = new GregorianCalendar(zone);\r
- cal.clear();\r
- cal.set(1900, 15, 5, 5, 8, 13);\r
- if (cal.get(Calendar.HOUR) != 5) {\r
- logln("Fail: " + zone.getID() + " " +\r
- zone.useDaylightTime() + "; DST_OFFSET = " +\r
- cal.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +\r
- cal.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +\r
- zone.getRawOffset() / (60*60*1000.0) +\r
- "; HOUR = " + cal.get(Calendar.HOUR));\r
- cal.clear();\r
- cal.set(1900, 15, 5, 5, 8, 13);\r
- if (cal.get(Calendar.HOUR) != 5) {\r
- logln("Fail: " + zone.getID() + " " +\r
- zone.useDaylightTime() + "; DST_OFFSET = " +\r
- cal.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +\r
- cal.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +\r
- zone.getRawOffset() / (60*60*1000.0) +\r
- "; HOUR = " + cal.get(Calendar.HOUR));\r
- cal.clear();\r
- cal.set(1900, 15, 5, 5, 8, 13);\r
- logln("ms = " + cal.getTime() + " (" + cal.getTime().getTime() + ")");\r
- cal.get(Calendar.HOUR);\r
- java.util.GregorianCalendar cal2 = new java.util.GregorianCalendar(java.util.TimeZone.getTimeZone(ids[i]));\r
- cal2.clear();\r
- cal2.set(1900, 15, 5, 5, 8, 13);\r
- cal2.get(Calendar.HOUR);\r
- logln("java.util.GC: " + zone.getID() + " " +\r
- zone.useDaylightTime() + "; DST_OFFSET = " +\r
- cal2.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +\r
- cal2.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +\r
- zone.getRawOffset() / (60*60*1000.0) +\r
- "; HOUR = " + cal.get(Calendar.HOUR));\r
- logln("ms = " + cal2.getTime() + " (" + cal2.getTime().getTime() + ")");\r
- bad = true;\r
- } else if (false) { // Change to true to debug\r
- logln("OK: " + zone.getID() + " " +\r
- zone.useDaylightTime() + " " +\r
- cal.get(Calendar.DST_OFFSET) / (60*60*1000) + " " +\r
- zone.getRawOffset() / (60*60*1000) +\r
- ": HOUR = " + cal.get(Calendar.HOUR));\r
- }\r
- }\r
- if (bad) errln("TimeZone problems with GC");\r
- }\r
- } catch (MissingResourceException e) {\r
- warnln("Could not load data. "+ e.getMessage());\r
- }\r
- }\r
-\r
- public void Test4035301() {\r
- \r
- try {\r
- GregorianCalendar c = new GregorianCalendar(98, 8, 7);\r
- GregorianCalendar d = new GregorianCalendar(98, 8, 7);\r
- if (c.after(d) ||\r
- c.after(c) ||\r
- c.before(d) ||\r
- c.before(c) ||\r
- !c.equals(c) ||\r
- !c.equals(d))\r
- errln("Fail");\r
- } catch (Exception e) {\r
- // TODO Auto-generated catch block\r
- warnln("Could not load data. "+ e.getMessage());\r
- }\r
- }\r
-\r
- public void Test4040996() {\r
- try {\r
- String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);\r
- SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);\r
- pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);\r
- pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);\r
- Calendar calendar = new GregorianCalendar(pdt);\r
-\r
- calendar.set(Calendar.MONTH,3);\r
- calendar.set(Calendar.DAY_OF_MONTH,18);\r
- calendar.set(Calendar.SECOND, 30);\r
-\r
- logln("MONTH: " + calendar.get(Calendar.MONTH));\r
- logln("DAY_OF_MONTH: " + \r
- calendar.get(Calendar.DAY_OF_MONTH));\r
- logln("MINUTE: " + calendar.get(Calendar.MINUTE));\r
- logln("SECOND: " + calendar.get(Calendar.SECOND));\r
-\r
- calendar.add(Calendar.SECOND,6);\r
- //This will print out todays date for MONTH and DAY_OF_MONTH\r
- //instead of the date it was set to.\r
- //This happens when adding MILLISECOND or MINUTE also\r
- logln("MONTH: " + calendar.get(Calendar.MONTH));\r
- logln("DAY_OF_MONTH: " + \r
- calendar.get(Calendar.DAY_OF_MONTH));\r
- logln("MINUTE: " + calendar.get(Calendar.MINUTE));\r
- logln("SECOND: " + calendar.get(Calendar.SECOND));\r
- if (calendar.get(Calendar.MONTH) != 3 ||\r
- calendar.get(Calendar.DAY_OF_MONTH) != 18 ||\r
- calendar.get(Calendar.SECOND) != 36)\r
- errln("Fail: Calendar.add misbehaves");\r
- } catch (Exception e) {\r
- warnln("Could not load data. "+ e.getMessage());\r
- }\r
- }\r
-\r
- public void Test4051765() {\r
- try {\r
- Calendar cal = Calendar.getInstance();\r
- cal.setLenient(false);\r
- cal.set(Calendar.DAY_OF_WEEK, 0);\r
- try {\r
- cal.getTime();\r
- errln("Fail: DAY_OF_WEEK 0 should be disallowed");\r
- }\r
- catch (IllegalArgumentException e) {\r
- return;\r
- }\r
- } catch (Exception e) {\r
- // TODO Auto-generated catch block\r
- warnln("Could not load data. "+ e.getMessage());\r
- }\r
- }\r
- \r
- /*\r
- * User error - no bug here public void Test4059524() { // Create calendar\r
- * for April 10, 1997 GregorianCalendar calendar = new GregorianCalendar(); //\r
- * print out a bunch of interesting things logln("ERA: " +\r
- * calendar.get(calendar.ERA)); logln("YEAR: " +\r
- * calendar.get(calendar.YEAR)); logln("MONTH: " +\r
- * calendar.get(calendar.MONTH)); logln("WEEK_OF_YEAR: " +\r
- * calendar.get(calendar.WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " +\r
- * calendar.get(calendar.WEEK_OF_MONTH)); logln("DATE: " +\r
- * calendar.get(calendar.DATE)); logln("DAY_OF_MONTH: " +\r
- * calendar.get(calendar.DAY_OF_MONTH)); logln("DAY_OF_YEAR: " +\r
- * calendar.get(calendar.DAY_OF_YEAR)); logln("DAY_OF_WEEK: " +\r
- * calendar.get(calendar.DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " +\r
- * calendar.get(calendar.DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " +\r
- * calendar.get(calendar.AM_PM)); logln("HOUR: " +\r
- * calendar.get(calendar.HOUR)); logln("HOUR_OF_DAY: " +\r
- * calendar.get(calendar.HOUR_OF_DAY)); logln("MINUTE: " +\r
- * calendar.get(calendar.MINUTE)); logln("SECOND: " +\r
- * calendar.get(calendar.SECOND)); logln("MILLISECOND: " +\r
- * calendar.get(calendar.MILLISECOND)); logln("ZONE_OFFSET: " +\r
- * (calendar.get(calendar.ZONE_OFFSET)/(60*60*1000))); logln("DST_OFFSET: " +\r
- * (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); calendar = new\r
- * GregorianCalendar(1997,3,10); calendar.getTime(); logln("April 10,\r
- * 1997"); logln("ERA: " + calendar.get(calendar.ERA)); logln("YEAR: " +\r
- * calendar.get(calendar.YEAR)); logln("MONTH: " +\r
- * calendar.get(calendar.MONTH)); logln("WEEK_OF_YEAR: " +\r
- * calendar.get(calendar.WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " +\r
- * calendar.get(calendar.WEEK_OF_MONTH)); logln("DATE: " +\r
- * calendar.get(calendar.DATE)); logln("DAY_OF_MONTH: " +\r
- * calendar.get(calendar.DAY_OF_MONTH)); logln("DAY_OF_YEAR: " +\r
- * calendar.get(calendar.DAY_OF_YEAR)); logln("DAY_OF_WEEK: " +\r
- * calendar.get(calendar.DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " +\r
- * calendar.get(calendar.DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " +\r
- * calendar.get(calendar.AM_PM)); logln("HOUR: " +\r
- * calendar.get(calendar.HOUR)); logln("HOUR_OF_DAY: " +\r
- * calendar.get(calendar.HOUR_OF_DAY)); logln("MINUTE: " +\r
- * calendar.get(calendar.MINUTE)); logln("SECOND: " +\r
- * calendar.get(calendar.SECOND)); logln("MILLISECOND: " +\r
- * calendar.get(calendar.MILLISECOND)); logln("ZONE_OFFSET: " +\r
- * (calendar.get(calendar.ZONE_OFFSET)/(60*60*1000))); // in hours\r
- * logln("DST_OFFSET: " + (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); //\r
- * in hours }\r
- */\r
-\r
- public void Test4059654() {\r
- // try {\r
- // work around bug for jdk1.4 on solaris 2.6, which uses funky\r
- // timezone names\r
- // jdk1.4.1 will drop support for 2.6 so we should be ok when it\r
- // comes out\r
- java.util.TimeZone javazone = java.util.TimeZone.getTimeZone("GMT");\r
- TimeZone icuzone = TimeZone.getTimeZone("GMT");\r
-\r
- GregorianCalendar gc = new GregorianCalendar(icuzone);\r
- \r
- gc.set(1997, 3, 1, 15, 16, 17); // April 1, 1997\r
-\r
- gc.set(Calendar.HOUR, 0);\r
- gc.set(Calendar.AM_PM, Calendar.AM);\r
- gc.set(Calendar.MINUTE, 0);\r
- gc.set(Calendar.SECOND, 0);\r
- gc.set(Calendar.MILLISECOND, 0);\r
-\r
- Date cd = gc.getTime();\r
- java.util.Calendar cal = java.util.Calendar.getInstance(javazone);\r
- cal.clear();\r
- cal.set(1997, 3, 1, 0, 0, 0);\r
- Date exp = cal.getTime();\r
- if (!cd.equals(exp))\r
- errln("Fail: Calendar.set broken. Got " + cd + " Want " + exp);\r
- // } catch (RuntimeException e) {\r
- // TODO Auto-generated catch block\r
- // e.printStackTrace();\r
- // }\r
- }\r
-\r
- public void Test4061476() {\r
- SimpleDateFormat fmt = new SimpleDateFormat("ddMMMyy", Locale.UK);\r
- Calendar cal = GregorianCalendar.getInstance(TimeZone.getTimeZone("GMT"), \r
- Locale.UK);\r
- fmt.setCalendar(cal);\r
- try\r
- {\r
- Date date = fmt.parse("29MAY97");\r
- cal.setTime(date);\r
- }\r
- catch (Exception e) {\r
- System.out.print("");\r
- }\r
- cal.set(Calendar.HOUR_OF_DAY, 13);\r
- logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));\r
- cal.add(Calendar.HOUR_OF_DAY, 6);\r
- logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));\r
- if (cal.get(Calendar.HOUR_OF_DAY) != 19)\r
- errln("Fail: Want 19 Got " + cal.get(Calendar.HOUR_OF_DAY));\r
- }\r
-\r
- public void Test4070502() {\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1998, 0, 30);\r
- Date d = getAssociatedDate(tempcal.getTime());\r
- Calendar cal = new GregorianCalendar();\r
- cal.setTime(d);\r
- if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY ||\r
- cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)\r
- errln("Fail: Want weekday Got " + d);\r
- }\r
-\r
- /**\r
- * Get the associated date starting from a specified date NOTE: the\r
- * unnecessary "getTime()'s" below are a work-around for a bug in jdk 1.1.3\r
- * (and probably earlier versions also)\r
- * <p>\r
- * \r
- * @param d\r
- * The date to start from\r
- */\r
- public static Date getAssociatedDate(Date d) {\r
- GregorianCalendar cal = new GregorianCalendar();\r
- cal.setTime(d);\r
- //cal.add(field, amount); //<-- PROBLEM SEEN WITH field = DATE,MONTH\r
- // cal.getTime(); // <--- REMOVE THIS TO SEE BUG\r
- while (true) {\r
- int wd = cal.get(Calendar.DAY_OF_WEEK);\r
- if (wd == Calendar.SATURDAY || wd == Calendar.SUNDAY) {\r
- cal.add(Calendar.DATE, 1);\r
- // cal.getTime();\r
- }\r
- else\r
- break;\r
- }\r
- return cal.getTime();\r
- }\r
-\r
- public void Test4071197() {\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,\r
- // 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
- logln(cal.getTime().toString());\r
- if (min != Calendar.SUNDAY || max != Calendar.SATURDAY)\r
- errln("FAIL: Min/max bad");\r
- if (dow < min || dow > max) \r
- errln("FAIL: Day of week " + dow + " out of range");\r
- if (dow != Calendar.SUNDAY) \r
- errln("FAIL: Day of week should be SUNDAY Got " + dow);\r
- }\r
-\r
- public void Test4071385() {\r
- // work around bug for jdk1.4 on solaris 2.6, which uses funky timezone\r
- // names\r
- // jdk1.4.1 will drop support for 2.6 so we should be ok when it comes out\r
- java.util.TimeZone javazone = java.util.TimeZone.getTimeZone("GMT");\r
- TimeZone icuzone = TimeZone.getTimeZone("GMT");\r
-\r
- Calendar cal = Calendar.getInstance(icuzone);\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance(javazone);\r
- tempcal.clear();\r
- tempcal.set(1998, Calendar.JUNE, 24);\r
- cal.setTime(tempcal.getTime());\r
- cal.set(Calendar.MONTH, Calendar.NOVEMBER); // change a field\r
- logln(cal.getTime().toString());\r
- tempcal.set(1998, Calendar.NOVEMBER, 24);\r
- if (!cal.getTime().equals(tempcal.getTime()))\r
- errln("Fail");\r
- }\r
-\r
- public void Test4073929() {\r
- GregorianCalendar foo1 = new GregorianCalendar(1997, 8, 27);\r
- foo1.add(Calendar.DAY_OF_MONTH, +1);\r
- int testyear = foo1.get(Calendar.YEAR);\r
- int testmonth = foo1.get(Calendar.MONTH);\r
- int testday = foo1.get(Calendar.DAY_OF_MONTH);\r
- if (testyear != 1997 ||\r
- testmonth != 8 ||\r
- testday != 28)\r
- errln("Fail: Calendar not initialized");\r
- }\r
-\r
- public void Test4083167() {\r
- TimeZone saveZone = TimeZone.getDefault();\r
- try {\r
- TimeZone.setDefault(TimeZone.getTimeZone("UTC"));\r
- Date firstDate = new Date();\r
- Calendar cal = new GregorianCalendar();\r
- cal.setTime(firstDate);\r
- long firstMillisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +\r
- cal.get(Calendar.MINUTE) * 60000L +\r
- cal.get(Calendar.SECOND) * 1000L +\r
- cal.get(Calendar.MILLISECOND);\r
- \r
- logln("Current time: " + firstDate.toString());\r
-\r
- for (int validity=0; validity<30; validity++) {\r
- Date lastDate = new Date(firstDate.getTime() +\r
- (long)validity*1000*24*60*60);\r
- cal.setTime(lastDate);\r
- long millisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +\r
- cal.get(Calendar.MINUTE) * 60000L +\r
- cal.get(Calendar.SECOND) * 1000L +\r
- cal.get(Calendar.MILLISECOND);\r
- if (firstMillisInDay != millisInDay) \r
- errln("Day has shifted " + lastDate);\r
- }\r
- }\r
- finally {\r
- TimeZone.setDefault(saveZone);\r
- }\r
- }\r
-\r
- public void Test4086724() {\r
- SimpleDateFormat date;\r
- TimeZone saveZone = TimeZone.getDefault();\r
- Locale saveLocale = Locale.getDefault();\r
- try {\r
- Locale.setDefault(Locale.UK); \r
- TimeZone.setDefault(TimeZone.getTimeZone("GMT"));\r
- date=new SimpleDateFormat("dd MMM yyy (zzzz) 'is in week' ww"); \r
- Calendar cal=Calendar.getInstance(); \r
- cal.set(1997,Calendar.SEPTEMBER,30); \r
- Date now=cal.getTime(); \r
- logln(date.format(now)); \r
- cal.set(1997,Calendar.JANUARY,1); \r
- now=cal.getTime(); \r
- logln(date.format(now)); \r
- cal.set(1997,Calendar.JANUARY,8); \r
- now=cal.getTime(); \r
- logln(date.format(now)); \r
- cal.set(1996,Calendar.DECEMBER,31); \r
- now=cal.getTime(); \r
- logln(date.format(now)); \r
- }\r
- finally {\r
- Locale.setDefault(saveLocale);\r
- TimeZone.setDefault(saveZone);\r
- }\r
- logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");\r
- }\r
-\r
- public void Test4092362() {\r
- GregorianCalendar cal1 = new GregorianCalendar(1997, 10, 11, 10, 20, 40); \r
- /*\r
- * cal1.set( Calendar.YEAR, 1997 ); cal1.set( Calendar.MONTH, 10 );\r
- * cal1.set( Calendar.DATE, 11 ); cal1.set( Calendar.HOUR, 10 );\r
- * cal1.set( Calendar.MINUTE, 20 ); cal1.set( Calendar.SECOND, 40 );\r
- */\r
-\r
- logln( " Cal1 = " + cal1.getTime().getTime() ); \r
- logln( " Cal1 time in ms = " + cal1.get(Calendar.MILLISECOND) ); \r
- for( int k = 0; k < 100 ; k++ ) {\r
- System.out.print(""); \r
- }\r
-\r
- GregorianCalendar cal2 = new GregorianCalendar(1997, 10, 11, 10, 20, 40); \r
- /*\r
- * cal2.set( Calendar.YEAR, 1997 ); cal2.set( Calendar.MONTH, 10 );\r
- * cal2.set( Calendar.DATE, 11 ); cal2.set( Calendar.HOUR, 10 );\r
- * cal2.set( Calendar.MINUTE, 20 ); cal2.set( Calendar.SECOND, 40 );\r
- */\r
-\r
- logln( " Cal2 = " + cal2.getTime().getTime() ); \r
- logln( " Cal2 time in ms = " + cal2.get(Calendar.MILLISECOND) ); \r
- if( !cal1.equals( cal2 ) ) \r
- errln("Fail: Milliseconds randomized");\r
- }\r
-\r
- public void Test4095407() {\r
- GregorianCalendar a = new GregorianCalendar(1997,Calendar.NOVEMBER, 13);\r
- int dow = a.get(Calendar.DAY_OF_WEEK);\r
- if (dow != Calendar.THURSDAY)\r
- errln("Fail: Want THURSDAY Got " + dow);\r
- }\r
-\r
- public void Test4096231() {\r
- TimeZone GMT = TimeZone.getTimeZone("GMT");\r
- TimeZone PST = TimeZone.getTimeZone("PST");\r
- int sec = 0, min = 0, hr = 0, day = 1, month = 10, year = 1997;\r
- \r
- Calendar cal1 = new GregorianCalendar(PST);\r
- cal1.setTime(new Date(880698639000L));\r
- int p;\r
- logln("PST 1 is: " + (p=cal1.get(Calendar.HOUR_OF_DAY)));\r
- cal1.setTimeZone(GMT);\r
- // Issue 1: Changing the timezone doesn't change the\r
- // represented time.\r
- int h1,h2;\r
- logln("GMT 1 is: " + (h1=cal1.get(Calendar.HOUR_OF_DAY)));\r
- cal1.setTime(new Date(880698639000L));\r
- logln("GMT 2 is: " + (h2=cal1.get(Calendar.HOUR_OF_DAY)));\r
- // Note: This test had a bug in it. It wanted h1!=h2, when\r
- // what was meant was h1!=p. Fixed this concurrent with fix\r
- // to 4177484.\r
- if (p == h1 || h1 != h2)\r
- errln("Fail: Hour same in different zones");\r
-\r
- Calendar cal2 = new GregorianCalendar(GMT);\r
- Calendar cal3 = new GregorianCalendar(PST);\r
- cal2.set(Calendar.MILLISECOND, 0);\r
- cal3.set(Calendar.MILLISECOND, 0);\r
-\r
- cal2.set(cal1.get(Calendar.YEAR),\r
- cal1.get(Calendar.MONTH),\r
- cal1.get(Calendar.DAY_OF_MONTH),\r
- cal1.get(Calendar.HOUR_OF_DAY),\r
- cal1.get(Calendar.MINUTE),\r
- cal1.get(Calendar.SECOND));\r
-\r
- long t1,t2,t3,t4;\r
- logln("RGMT 1 is: " + (t1=cal2.getTime().getTime()));\r
- cal3.set(year, month, day, hr, min, sec);\r
- logln("RPST 1 is: " + (t2=cal3.getTime().getTime()));\r
- cal3.setTimeZone(GMT);\r
- logln("RGMT 2 is: " + (t3=cal3.getTime().getTime()));\r
- cal3.set(cal1.get(Calendar.YEAR),\r
- cal1.get(Calendar.MONTH),\r
- cal1.get(Calendar.DAY_OF_MONTH),\r
- cal1.get(Calendar.HOUR_OF_DAY),\r
- cal1.get(Calendar.MINUTE),\r
- cal1.get(Calendar.SECOND));\r
- // Issue 2: Calendar continues to use the timezone in its\r
- // constructor for set() conversions, regardless\r
- // of calls to setTimeZone()\r
- logln("RGMT 3 is: " + (t4=cal3.getTime().getTime()));\r
- if (t1 == t2 ||\r
- t1 != t4 ||\r
- t2 != t3)\r
- errln("Fail: Calendar zone behavior faulty");\r
- }\r
-\r
- public void Test4096539() {\r
- int[] y = {31,28,31,30,31,30,31,31,30,31,30,31};\r
-\r
- for (int x=0;x<12;x++) {\r
- GregorianCalendar gc = new \r
- GregorianCalendar(1997,x,y[x]);\r
- int m1,m2;\r
- log((m1=gc.get(Calendar.MONTH)+1)+"/"+\r
- gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)+\r
- " + 1mo = ");\r
-\r
- gc.add(Calendar.MONTH, 1);\r
- logln((m2=gc.get(Calendar.MONTH)+1)+"/"+\r
- gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)\r
- );\r
- int m = (m1 % 12) + 1;\r
- if (m2 != m)\r
- errln("Fail: Want " + m + " Got " + m2);\r
- }\r
- \r
- }\r
-\r
- public void Test4100311() {\r
- GregorianCalendar cal = (GregorianCalendar)Calendar.getInstance();\r
- cal.set(Calendar.YEAR, 1997);\r
- cal.set(Calendar.DAY_OF_YEAR, 1);\r
- Date d = cal.getTime(); // Should be Jan 1\r
- logln(d.toString());\r
- if (cal.get(Calendar.DAY_OF_YEAR) != 1)\r
- errln("Fail: DAY_OF_YEAR not set");\r
- }\r
-\r
- public void Test4103271() {\r
- SimpleDateFormat sdf = new SimpleDateFormat(); \r
- int numYears=40, startYear=1997, numDays=15; \r
- String output, testDesc; \r
- GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance(); \r
- testCal.clear();\r
- sdf.setCalendar(testCal); \r
- sdf.applyPattern("d MMM yyyy"); \r
- boolean fail = false;\r
- for (int firstDay=1; firstDay<=2; firstDay++) { \r
- for (int minDays=1; minDays<=7; minDays++) { \r
- testCal.setMinimalDaysInFirstWeek(minDays); \r
- testCal.setFirstDayOfWeek(firstDay); \r
- testDesc = ("Test" + String.valueOf(firstDay) + String.valueOf(minDays)); \r
- logln(testDesc + " => 1st day of week=" +\r
- String.valueOf(firstDay) +\r
- ", minimum days in first week=" +\r
- String.valueOf(minDays)); \r
- for (int j=startYear; j<=startYear+numYears; j++) { \r
- testCal.set(j,11,25); \r
- for(int i=0; i<numDays; i++) { \r
- testCal.add(Calendar.DATE,1); \r
- String calWOY; \r
- int actWOY = testCal.get(Calendar.WEEK_OF_YEAR);\r
- if (actWOY < 1 || actWOY > 53) {\r
- Date d = testCal.getTime(); \r
- calWOY = String.valueOf(actWOY); \r
- output = testDesc + " - " + sdf.format(d) + "\t"; \r
- output = output + "\t" + calWOY; \r
- logln(output); \r
- fail = true;\r
- }\r
- } \r
- } \r
- } \r
- } \r
-\r
- int[] DATA = {\r
- 3, 52, 52, 52, 52, 52, 52, 52,\r
- 1, 1, 1, 1, 1, 1, 1,\r
- 2, 2, 2, 2, 2, 2, 2,\r
- 4, 52, 52, 52, 52, 52, 52, 52,\r
- 53, 53, 53, 53, 53, 53, 53,\r
- 1, 1, 1, 1, 1, 1, 1,\r
- };\r
- testCal.setFirstDayOfWeek(Calendar.SUNDAY);\r
- for (int j=0; j<DATA.length; j+=22) {\r
- logln("Minimal days in first week = " + DATA[j] +\r
- " Week starts on Sunday");\r
- testCal.setMinimalDaysInFirstWeek(DATA[j]);\r
- testCal.set(1997, Calendar.DECEMBER, 21);\r
- for (int i=0; i<21; ++i) {\r
- int woy = testCal.get(Calendar.WEEK_OF_YEAR);\r
- log(testCal.getTime() + " " + woy);\r
- if (woy != DATA[j + 1 + i]) {\r
- log(" ERROR");\r
- fail = true;\r
- }\r
- //logln();\r
- \r
- // Now compute the time from the fields, and make sure we\r
- // get the same answer back. This is a round-trip test.\r
- Date save = testCal.getTime();\r
- testCal.clear();\r
- testCal.set(Calendar.YEAR, DATA[j+1+i] < 25 ? 1998 : 1997);\r
- testCal.set(Calendar.WEEK_OF_YEAR, DATA[j+1+i]);\r
- testCal.set(Calendar.DAY_OF_WEEK, (i%7) + Calendar.SUNDAY);\r
- if (!testCal.getTime().equals(save)) {\r
- logln(" Parse failed: " + testCal.getTime());\r
- fail= true;\r
- }\r
-\r
- testCal.setTime(save);\r
- testCal.add(Calendar.DAY_OF_MONTH, 1);\r
- }\r
- }\r
-\r
- Date d[] = new Date[8];\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1997, Calendar.DECEMBER, 28);\r
- d[0] = tempcal.getTime();\r
- tempcal.set(1998, Calendar.JANUARY, 10);\r
- d[1] = tempcal.getTime();\r
- tempcal.set(1998, Calendar.DECEMBER, 31);\r
- d[2] = tempcal.getTime();\r
- tempcal.set(1999, Calendar.JANUARY, 1);\r
- d[3] = tempcal.getTime();\r
- // Test field disambiguation with a few special hard-coded cases.\r
- // This shouldn't fail if the above cases aren't failing.\r
- Object[] DISAM = {\r
- new Integer(1998), new Integer(1), new Integer(Calendar.SUNDAY),\r
- d[0],\r
- new Integer(1998), new Integer(2), new Integer(Calendar.SATURDAY),\r
- d[1],\r
- new Integer(1998), new Integer(53), new Integer(Calendar.THURSDAY),\r
- d[2],\r
- new Integer(1998), new Integer(53), new Integer(Calendar.FRIDAY),\r
- d[3],\r
- };\r
- testCal.setMinimalDaysInFirstWeek(3);\r
- testCal.setFirstDayOfWeek(Calendar.SUNDAY);\r
- for (int i=0; i<DISAM.length; i+=4) {\r
- int y = ((Integer)DISAM[i]).intValue();\r
- int woy = ((Integer)DISAM[i+1]).intValue();\r
- int dow = ((Integer)DISAM[i+2]).intValue();\r
- Date exp = (Date)DISAM[i+3];\r
- testCal.clear();\r
- testCal.set(Calendar.YEAR, y);\r
- testCal.set(Calendar.WEEK_OF_YEAR, woy);\r
- testCal.set(Calendar.DAY_OF_WEEK, dow);\r
- log(y + "-W" + woy +\r
- "-DOW" + dow + " expect:" + exp +\r
- " got:" + testCal.getTime());\r
- if (!testCal.getTime().equals(exp)) {\r
- log(" FAIL");\r
- fail = true;\r
- }\r
- //logln();\r
- }\r
-\r
- // Now try adding and rolling\r
- Object ADD = new Object();\r
- Object ROLL = new Object();\r
- tempcal.set(1998, Calendar.DECEMBER, 25);\r
- d[0] = tempcal.getTime();\r
- tempcal.set(1999, Calendar.JANUARY, 1);\r
- d[1] = tempcal.getTime();\r
- tempcal.set(1997, Calendar.DECEMBER, 28);\r
- d[2] = tempcal.getTime();\r
- tempcal.set(1998, Calendar.JANUARY, 4);\r
- d[3] = tempcal.getTime();\r
- tempcal.set(1998, Calendar.DECEMBER, 27);\r
- d[4] = tempcal.getTime();\r
- tempcal.set(1997, Calendar.DECEMBER, 28);\r
- d[5] = tempcal.getTime();\r
- tempcal.set(1999, Calendar.JANUARY, 2);\r
- d[6] = tempcal.getTime();\r
- tempcal.set(1998, Calendar.JANUARY, 3);\r
- d[7] = tempcal.getTime();\r
- \r
- Object[] ADDROLL = {\r
- ADD, new Integer(1), d[0], d[1],\r
- ADD, new Integer(1), d[2], d[3],\r
- ROLL, new Integer(1), d[4], d[5],\r
- ROLL, new Integer(1), d[6], d[7],\r
- };\r
- testCal.setMinimalDaysInFirstWeek(3);\r
- testCal.setFirstDayOfWeek(Calendar.SUNDAY);\r
- for (int i=0; i<ADDROLL.length; i+=4) {\r
- int amount = ((Integer)ADDROLL[i+1]).intValue();\r
- Date before = (Date)ADDROLL[i+2];\r
- Date after = (Date)ADDROLL[i+3];\r
-\r
- testCal.setTime(before);\r
- if (ADDROLL[i] == ADD) testCal.add(Calendar.WEEK_OF_YEAR, amount);\r
- else testCal.roll(Calendar.WEEK_OF_YEAR, amount);\r
- log((ADDROLL[i]==ADD?"add(WOY,":"roll(WOY,") +\r
- amount + ") " + before + " => " +\r
- testCal.getTime());\r
- if (!after.equals(testCal.getTime())) {\r
- logln(" exp:" + after + " FAIL");\r
- fail = true;\r
- }\r
- else logln(" ok");\r
-\r
- testCal.setTime(after);\r
- if (ADDROLL[i] == ADD) testCal.add(Calendar.WEEK_OF_YEAR, -amount);\r
- else testCal.roll(Calendar.WEEK_OF_YEAR, -amount);\r
- log((ADDROLL[i]==ADD?"add(WOY,":"roll(WOY,") +\r
- (-amount) + ") " + after + " => " +\r
- testCal.getTime());\r
- if (!before.equals(testCal.getTime())) {\r
- logln(" exp:" + before + " FAIL");\r
- fail = true;\r
- }\r
- else logln(" ok");\r
- }\r
-\r
- if (fail) errln("Fail: Week of year misbehaving");\r
- } \r
-\r
- public void Test4106136() {\r
- Locale saveLocale = Locale.getDefault();\r
- String[] names = { "Calendar", "DateFormat", "NumberFormat" };\r
- try {\r
- Locale[] locales = { Locale.CHINESE, Locale.CHINA };\r
- for (int i=0; i<locales.length; ++i) {\r
- Locale.setDefault(locales[i]);\r
- int[] n = {\r
- Calendar.getAvailableLocales().length,\r
- DateFormat.getAvailableLocales().length,\r
- NumberFormat.getAvailableLocales().length\r
- };\r
- for (int j=0; j<n.length; ++j) {\r
- if (n[j] == 0)\r
- errln("Fail: " + names[j] + " has no locales for " + locales[i]);\r
- }\r
- }\r
- }\r
- finally {\r
- Locale.setDefault(saveLocale);\r
- }\r
- }\r
-\r
- public void Test4108764() {\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 00, 00);\r
- Date d00 = tempcal.getTime();\r
- tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 00, 56);\r
- Date d01 = tempcal.getTime();\r
- tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 34, 00);\r
- Date d10 = tempcal.getTime();\r
- tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 34, 56);\r
- Date d11 = tempcal.getTime();\r
- tempcal.set(1997, Calendar.JANUARY, 15, 12, 34, 56);\r
- Date dM = tempcal.getTime();\r
- tempcal.clear();\r
- tempcal.set(1970, Calendar.JANUARY, 1);\r
- Date epoch = tempcal.getTime();\r
-\r
- Calendar cal = Calendar.getInstance(); \r
- cal.setTime(d11);\r
-\r
- cal.clear( Calendar.MINUTE ); \r
- logln(cal.getTime().toString()); \r
- if (!cal.getTime().equals(d01)) {\r
- errln("Fail: " + d11 + " clear(MINUTE) => expect " +\r
- d01 + ", got " + cal.getTime());\r
- }\r
-\r
- cal.set( Calendar.SECOND, 0 ); \r
- logln(cal.getTime().toString()); \r
- if (!cal.getTime().equals(d00))\r
- errln("Fail: set(SECOND, 0) broken");\r
-\r
- cal.setTime(d11);\r
- cal.set( Calendar.SECOND, 0 ); \r
- logln(cal.getTime().toString()); \r
- if (!cal.getTime().equals(d10))\r
- errln("Fail: set(SECOND, 0) broken #2");\r
-\r
- cal.clear( Calendar.MINUTE ); \r
- logln(cal.getTime().toString()); \r
- if (!cal.getTime().equals(d00))\r
- errln("Fail: clear(MINUTE) broken #2");\r
-\r
- cal.clear();\r
- logln(cal.getTime().toString());\r
- if (!cal.getTime().equals(epoch))\r
- errln("Fail: after clear() expect " + epoch + ", got " + cal.getTime());\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. March 15\r
-//## // was not in DST before, but with the new rule, it is\r
-//## // in DST.\r
-//#else\r
- cal.setTime(d11);\r
- cal.clear( Calendar.MONTH ); \r
- logln(cal.getTime().toString()); \r
- if (!cal.getTime().equals(dM)) {\r
- errln("Fail: " + d11 + " clear(MONTH) => expect " +\r
- dM + ", got " + cal.getTime());\r
- }\r
-//#endif\r
- }\r
-\r
- public void Test4114578() {\r
- int ONE_HOUR = 60*60*1000;\r
- Calendar cal = Calendar.getInstance();\r
- cal.setTimeZone(TimeZone.getTimeZone("PST"));\r
- \r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1998, Calendar.APRIL, 5, 1, 0);\r
- long onset = tempcal.getTime().getTime() + ONE_HOUR;\r
- tempcal.set(1998, Calendar.OCTOBER, 25, 0, 0);\r
- long cease = tempcal.getTime().getTime() + 2*ONE_HOUR;\r
-\r
- boolean fail = false;\r
- \r
- final int ADD = 1;\r
- final int ROLL = 2;\r
-\r
- long[] DATA = {\r
- // Start Action Amt Expected_change\r
- onset - ONE_HOUR, ADD, 1, ONE_HOUR,\r
- onset, ADD, -1, -ONE_HOUR,\r
- onset - ONE_HOUR, ROLL, 1, ONE_HOUR,\r
- onset, ROLL, -1, -ONE_HOUR,\r
- cease - ONE_HOUR, ADD, 1, ONE_HOUR,\r
- cease, ADD, -1, -ONE_HOUR,\r
- cease - ONE_HOUR, ROLL, 1, ONE_HOUR,\r
- cease, ROLL, -1, -ONE_HOUR,\r
- };\r
-\r
- for (int i=0; i<DATA.length; i+=4) {\r
- Date date = new Date(DATA[i]);\r
- int amt = (int) DATA[i+2];\r
- long expectedChange = DATA[i+3];\r
- \r
- log(date.toString());\r
- cal.setTime(date);\r
-\r
- switch ((int) DATA[i+1]) {\r
- case ADD:\r
- log(" add (HOUR," + (amt<0?"":"+")+amt + ")= ");\r
- cal.add(Calendar.HOUR, amt);\r
- break;\r
- case ROLL:\r
- log(" roll(HOUR," + (amt<0?"":"+")+amt + ")= ");\r
- cal.roll(Calendar.HOUR, amt);\r
- break;\r
- }\r
-\r
- log(cal.getTime().toString());\r
-\r
- long change = cal.getTime().getTime() - date.getTime();\r
- if (change != expectedChange) {\r
- fail = true;\r
- logln(" FAIL");\r
- }\r
- else logln(" OK");\r
- }\r
-\r
- if (fail) errln("Fail: roll/add misbehaves around DST onset/cease");\r
- }\r
-\r
- /**\r
- * Make sure maximum for HOUR field is 11, not 12.\r
- */\r
- public void Test4118384() {\r
- Calendar cal = Calendar.getInstance();\r
- if (cal.getMaximum(Calendar.HOUR) != 11 ||\r
- cal.getLeastMaximum(Calendar.HOUR) != 11 ||\r
- cal.getActualMaximum(Calendar.HOUR) != 11)\r
- errln("Fail: maximum of HOUR field should be 11");\r
- }\r
-\r
- /**\r
- * Check isLeapYear for BC years.\r
- */\r
- public void Test4125881() {\r
- GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();\r
- DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");\r
- cal.clear();\r
- for (int y=-20; y<=10; ++y) {\r
- cal.set(Calendar.ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);\r
- cal.set(Calendar.YEAR, y < 1 ? 1 - y : y);\r
- logln(y + " = " + fmt.format(cal.getTime()) + " " +\r
- cal.isLeapYear(y));\r
- if (cal.isLeapYear(y) != ((y+40)%4 == 0))\r
- errln("Leap years broken");\r
- }\r
- }\r
-\r
- // I am disabling this test -- it is currently failing because of a bug\r
- // in Sun's latest change to STZ.getOffset(). I have filed a Sun bug\r
- // against this problem.\r
-\r
- // Re-enabled after 'porting' TZ and STZ from java.util to com.ibm.icu.util.\r
- /**\r
- * Prove that GregorianCalendar is proleptic (it used to cut off at 45 BC,\r
- * and not have leap years before then).\r
- */\r
- public void Test4125892() {\r
- GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();\r
- //DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");\r
- //fmt = null;\r
- cal.clear();\r
- cal.set(Calendar.ERA, GregorianCalendar.BC);\r
- cal.set(Calendar.YEAR, 81); // 81 BC is a leap year (proleptically)\r
- cal.set(Calendar.MONTH, Calendar.FEBRUARY);\r
- cal.set(Calendar.DATE, 28);\r
- cal.add(Calendar.DATE, 1);\r
- if (cal.get(Calendar.DATE) != 29 ||\r
- !cal.isLeapYear(-80)) // -80 == 81 BC\r
- errln("Calendar not proleptic");\r
- }\r
-\r
- /**\r
- * Calendar and GregorianCalendar hashCode() methods need improvement.\r
- * Calendar needs a good implementation that subclasses can override, and\r
- * GregorianCalendar should use that implementation.\r
- */\r
- public void Test4136399() {\r
- /*\r
- * Note: This test is actually more strict than it has to be.\r
- * Technically, there is no requirement that unequal objects have\r
- * unequal hashes. We only require equal objects to have equal hashes.\r
- * It is desirable for unequal objects to have distributed hashes, but\r
- * there is no hard requirement here.\r
- * \r
- * In this test we make assumptions about certain attributes of calendar\r
- * objects getting represented in the hash, which need not always be the\r
- * case (although it does work currently with the given test).\r
- */\r
- Calendar a = Calendar.getInstance();\r
- Calendar b = (Calendar)a.clone();\r
- if (a.hashCode() != b.hashCode()) {\r
- errln("Calendar hash code unequal for cloned objects");\r
- }\r
- TimeZone atz1 = a.getTimeZone();\r
- TimeZone atz2 = (TimeZone)atz1.clone();\r
- if(!atz1.equals(atz2)){\r
- errln("The clone timezones are not equal");\r
- }\r
- if(atz1.hashCode()!=atz2.hashCode()){\r
- errln("TimeZone hash code unequal for cloned objects");\r
- }\r
- b.setMinimalDaysInFirstWeek(7 - a.getMinimalDaysInFirstWeek());\r
- if (a.hashCode() == b.hashCode()) {\r
- errln("Calendar hash code ignores minimal days in first week");\r
- }\r
- b.setMinimalDaysInFirstWeek(a.getMinimalDaysInFirstWeek());\r
-\r
- b.setFirstDayOfWeek((a.getFirstDayOfWeek() % 7) + 1); // Next day\r
- if (a.hashCode() == b.hashCode()) {\r
- errln("Calendar hash code ignores first day of week");\r
- }\r
- b.setFirstDayOfWeek(a.getFirstDayOfWeek());\r
-\r
- b.setLenient(!a.isLenient());\r
- if (a.hashCode() == b.hashCode()) {\r
- errln("Calendar hash code ignores lenient setting");\r
- }\r
- b.setLenient(a.isLenient());\r
- \r
- // Assume getTimeZone() returns a reference, not a clone\r
- // of a reference -- this is true as of this writing\r
- TimeZone atz = a.getTimeZone();\r
- TimeZone btz = b.getTimeZone();\r
-\r
- btz.setRawOffset(atz.getRawOffset() + 60*60*1000);\r
- if(atz.hashCode()== btz.hashCode()){\r
- errln(atz.hashCode()+"=="+btz.hashCode());\r
- }\r
- if (a.getTimeZone()!= b.getTimeZone() && a.hashCode() == b.hashCode()) {\r
- errln("Calendar hash code ignores zone");\r
- }\r
- b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset());\r
-\r
- GregorianCalendar c = new GregorianCalendar();\r
- GregorianCalendar d = (GregorianCalendar)c.clone();\r
- if (c.hashCode() != d.hashCode()) {\r
- errln("GregorianCalendar hash code unequal for clones objects");\r
- }\r
- Date cutover = c.getGregorianChange();\r
- d.setGregorianChange(new Date(cutover.getTime() + 24*60*60*1000));\r
- if (c.hashCode() == d.hashCode()) {\r
- errln("GregorianCalendar hash code ignores cutover");\r
- } \r
- }\r
-\r
- /**\r
- * GregorianCalendar.equals() ignores cutover date\r
- */\r
- public void Test4141665() {\r
- GregorianCalendar cal = new GregorianCalendar();\r
- GregorianCalendar cal2 = (GregorianCalendar)cal.clone();\r
- Date cut = cal.getGregorianChange();\r
- Date cut2 = new Date(cut.getTime() + 100*24*60*60*1000L); // 100 days\r
- // later\r
- if (!cal.equals(cal2)) {\r
- errln("Cloned GregorianCalendars not equal");\r
- }\r
- cal2.setGregorianChange(cut2);\r
- if (cal.equals(cal2)) {\r
- errln("GregorianCalendar.equals() ignores cutover");\r
- }\r
- }\r
- \r
- /**\r
- * Bug states that ArrayIndexOutOfBoundsException is thrown by\r
- * GregorianCalendar.roll() when IllegalArgumentException should be.\r
- */\r
- public void Test4142933() {\r
- GregorianCalendar calendar = new GregorianCalendar();\r
- try {\r
- calendar.roll(-1, true);\r
- errln("Test failed, no exception trown");\r
- }\r
- catch (IllegalArgumentException e) {\r
- // OK: Do nothing\r
- // logln("Test passed");\r
- System.out.print("");\r
- }\r
- catch (Exception e) {\r
- errln("Test failed. Unexpected exception is thrown: " + e);\r
- e.printStackTrace();\r
- } \r
- }\r
-\r
- /**\r
- * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is\r
- * confusing; unless the time zone has a raw offset of zero, one or the\r
- * other of these will wrap. We've modified the test given in the bug report\r
- * to therefore only check the behavior of a calendar with a zero raw offset\r
- * zone.\r
- */\r
- public void Test4145158() {\r
- GregorianCalendar calendar = new GregorianCalendar();\r
-\r
- calendar.setTimeZone(TimeZone.getTimeZone("GMT"));\r
-\r
- calendar.setTime(new Date(Long.MIN_VALUE));\r
- int year1 = calendar.get(Calendar.YEAR);\r
- int era1 = calendar.get(Calendar.ERA);\r
- \r
- calendar.setTime(new Date(Long.MAX_VALUE));\r
- int year2 = calendar.get(Calendar.YEAR);\r
- int era2 = calendar.get(Calendar.ERA);\r
- \r
- if (year1 == year2 && era1 == era2) {\r
- errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");\r
- }\r
- }\r
-\r
- /**\r
- * Maximum value for YEAR field wrong.\r
- */\r
- public void Test4145983() {\r
- GregorianCalendar calendar = new GregorianCalendar();\r
- calendar.setTimeZone(TimeZone.getTimeZone("GMT"));\r
- Date[] DATES = { new Date(Long.MAX_VALUE), new Date(Long.MIN_VALUE) };\r
- for (int i=0; i<DATES.length; ++i) {\r
- calendar.setTime(DATES[i]);\r
- int year = calendar.get(Calendar.YEAR);\r
- int maxYear = calendar.getMaximum(Calendar.YEAR);\r
- if (year > maxYear) {\r
- errln("Failed for "+DATES[i].getTime()+" ms: year=" +\r
- year + ", maxYear=" + maxYear);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * This is a bug in the validation code of GregorianCalendar. As reported,\r
- * the bug seems worse than it really is, due to a bug in the way the bug\r
- * report test was written. In reality the bug is restricted to the\r
- * DAY_OF_YEAR field. - liu 6/29/98\r
- */\r
- public void Test4147269() {\r
- GregorianCalendar calendar = new GregorianCalendar();\r
- calendar.setLenient(false);\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(1996, Calendar.JANUARY, 3); // Arbitrary date\r
- Date date = tempcal.getTime(); \r
- for (int field = 0; field < calendar.getFieldCount(); field++) {\r
- calendar.setTime(date);\r
- // Note: In the bug report, getActualMaximum() was called instead\r
- // of getMaximum() -- this was an error. The validation code doesn't\r
- // use getActualMaximum(), since that's too costly.\r
- int max = calendar.getMaximum(field);\r
- int value = max+1;\r
- calendar.set(field, value); \r
- try {\r
- calendar.getTime(); // Force time computation\r
- // We expect an exception to be thrown. If we fall through\r
- // to the next line, then we have a bug.\r
- errln("Test failed with field " + FIELD_NAME[field] +\r
- ", date before: " + date +\r
- ", date after: " + calendar.getTime() +\r
- ", value: " + value + " (max = " + max +")");\r
- } catch (IllegalArgumentException e) {\r
- System.out.print("");\r
- } \r
- }\r
- }\r
-\r
- /**\r
- * Reported bug is that a GregorianCalendar with a cutover of\r
- * Date(Long.MAX_VALUE) doesn't behave as a pure Julian calendar. CANNOT\r
- * REPRODUCE THIS BUG\r
- */\r
- public void Test4149677() {\r
- TimeZone[] zones = { TimeZone.getTimeZone("GMT"),\r
- TimeZone.getTimeZone("PST"),\r
- TimeZone.getTimeZone("EAT") };\r
- for (int i=0; i<zones.length; ++i) {\r
- GregorianCalendar calendar = new GregorianCalendar(zones[i]);\r
-\r
- // Make sure extreme values don't wrap around\r
- calendar.setTime(new Date(Long.MIN_VALUE));\r
- if (calendar.get(Calendar.ERA) != GregorianCalendar.BC) {\r
- errln("Fail: Long.MIN_VALUE ms has an AD year");\r
- }\r
- calendar.setTime(new Date(Long.MAX_VALUE));\r
- if (calendar.get(Calendar.ERA) != GregorianCalendar.AD) {\r
- errln("Fail: Long.MAX_VALUE ms has a BC year");\r
- }\r
-\r
- calendar.setGregorianChange(new Date(Long.MAX_VALUE));\r
- // to obtain a pure Julian calendar\r
- \r
- boolean is100Leap = calendar.isLeapYear(100);\r
- if (!is100Leap) {\r
- errln("test failed with zone " + zones[i].getID());\r
- errln(" cutover date is Calendar.MAX_DATE");\r
- errln(" isLeapYear(100) returns: " + is100Leap);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Calendar and Date HOUR broken. If HOUR is out-of-range, Calendar and Date\r
- * classes will misbehave.\r
- */\r
- public void Test4162587() {\r
- TimeZone tz = TimeZone.getTimeZone("PST");\r
- TimeZone.setDefault(tz);\r
- GregorianCalendar cal = new GregorianCalendar(tz);\r
- Date d;\r
- \r
- for (int i=0; i<5; ++i) {\r
- if (i>0) logln("---");\r
-\r
- cal.clear();\r
- cal.set(1998, Calendar.APRIL, 5, i, 0);\r
- d = cal.getTime();\r
- String s0 = d.toString();\r
- logln("0 " + i + ": " + s0);\r
-\r
- cal.clear();\r
- cal.set(1998, Calendar.APRIL, 4, i+24, 0);\r
- d = cal.getTime();\r
- String sPlus = d.toString();\r
- logln("+ " + i + ": " + sPlus);\r
-\r
- cal.clear();\r
- cal.set(1998, Calendar.APRIL, 6, i-24, 0);\r
- d = cal.getTime();\r
- String sMinus = d.toString();\r
- logln("- " + i + ": " + sMinus);\r
-\r
- if (!s0.equals(sPlus) || !s0.equals(sMinus)) {\r
- errln("Fail: All three lines must match");\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Adding 12 months behaves differently from adding 1 year\r
- */\r
- public void Test4165343() {\r
- GregorianCalendar calendar = new GregorianCalendar(1996, Calendar.FEBRUARY, 29);\r
- Date start = calendar.getTime();\r
- logln("init date: " + start);\r
- calendar.add(Calendar.MONTH, 12); \r
- Date date1 = calendar.getTime();\r
- logln("after adding 12 months: " + date1);\r
- calendar.setTime(start);\r
- calendar.add(Calendar.YEAR, 1);\r
- Date date2 = calendar.getTime();\r
- logln("after adding one year : " + date2);\r
- if (date1.equals(date2)) {\r
- logln("Test passed");\r
- } else {\r
- errln("Test failed");\r
- }\r
- }\r
-\r
- /**\r
- * GregorianCalendar.getActualMaximum() does not account for first day of\r
- * week.\r
- */\r
- public void Test4166109() {\r
- /*\r
- * Test month:\r
- * \r
- * March 1998 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15\r
- * 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\r
- */\r
- boolean passed = true;\r
- int field = Calendar.WEEK_OF_MONTH;\r
-\r
- GregorianCalendar calendar = new GregorianCalendar(Locale.US);\r
- calendar.set(1998, Calendar.MARCH, 1);\r
- calendar.setMinimalDaysInFirstWeek(1);\r
- logln("Date: " + calendar.getTime());\r
-\r
- int firstInMonth = calendar.get(Calendar.DAY_OF_MONTH);\r
-\r
- for (int firstInWeek = Calendar.SUNDAY; firstInWeek <= Calendar.SATURDAY; firstInWeek++) {\r
- calendar.setFirstDayOfWeek(firstInWeek);\r
- int returned = calendar.getActualMaximum(field);\r
- int expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7;\r
-\r
- logln("First day of week = " + firstInWeek +\r
- " getActualMaximum(WEEK_OF_MONTH) = " + returned +\r
- " expected = " + expected +\r
- ((returned == expected) ? " ok" : " FAIL"));\r
-\r
- if (returned != expected) {\r
- passed = false;\r
- }\r
- }\r
- if (!passed) {\r
- errln("Test failed");\r
- }\r
- }\r
-\r
- /**\r
- * Calendar.getActualMaximum(YEAR) works wrong.\r
- */\r
- public void Test4167060() {\r
- int field = Calendar.YEAR;\r
- DateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy G",\r
- Locale.US);\r
-\r
- GregorianCalendar calendars[] = {\r
- new GregorianCalendar(100, Calendar.NOVEMBER, 1),\r
- new GregorianCalendar(-99 /* 100BC */, Calendar.JANUARY, 1),\r
- new GregorianCalendar(1996, Calendar.FEBRUARY, 29),\r
- };\r
-\r
- String[] id = { "Hybrid", "Gregorian", "Julian" };\r
-\r
- for (int k=0; k<3; ++k) {\r
- logln("--- " + id[k] + " ---");\r
-\r
- for (int j=0; j<calendars.length; ++j) {\r
- GregorianCalendar calendar = calendars[j];\r
- if (k == 1) {\r
- calendar.setGregorianChange(new Date(Long.MIN_VALUE));\r
- } else if (k == 2) {\r
- calendar.setGregorianChange(new Date(Long.MAX_VALUE));\r
- }\r
-\r
- format.setCalendar((Calendar)calendar.clone());\r
-\r
- Date dateBefore = calendar.getTime();\r
-\r
- int maxYear = calendar.getActualMaximum(field);\r
- logln("maxYear: " + maxYear + " for " + format.format(calendar.getTime()));\r
- logln("date before: " + format.format(dateBefore));\r
-\r
- int years[] = {2000, maxYear-1, maxYear, maxYear+1};\r
-\r
- for (int i = 0; i < years.length; i++) {\r
- boolean valid = years[i] <= maxYear;\r
- calendar.set(field, years[i]);\r
- Date dateAfter = calendar.getTime();\r
- int newYear = calendar.get(field);\r
- calendar.setTime(dateBefore); // restore calendar for next\r
- // use\r
-\r
- logln(" Year " + years[i] + (valid? " ok " : " bad") +\r
- " => " + format.format(dateAfter));\r
- if (valid && newYear != years[i]) {\r
- errln(" FAIL: " + newYear + " should be valid; date, month and time shouldn't change");\r
- } else if (!valid && newYear == years[i]) {\r
- // We no longer require strict year maxima. That is, the\r
- // calendar\r
- // algorithm may work for values > the stated maximum.\r
- //errln(" FAIL: " + newYear + " should be invalid");\r
- logln(" Note: " + newYear + " > maximum, but still valid");\r
- }\r
- }\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Calendar.roll broken This bug relies on the TimeZone bug 4173604 to also\r
- * be fixed.\r
- */\r
- public void Test4173516() {\r
- int fieldsList[][] = {\r
- { 1997, Calendar.FEBRUARY, 1, 10, 45, 15, 900 },\r
- { 1999, Calendar.DECEMBER, 22, 23, 59, 59, 999 }\r
- };\r
- int limit = 40;\r
- GregorianCalendar cal = new GregorianCalendar();\r
-\r
- cal.setTime(new Date(0));\r
- cal.roll(Calendar.HOUR, 0x7F000000);\r
- cal.roll(Calendar.HOUR, -0x7F000000);\r
- if (cal.getTime().getTime() != 0) {\r
- errln("Hour rolling broken");\r
- }\r
-\r
- for (int op=0; op<2; ++op) {\r
- logln("Testing GregorianCalendar " +\r
- (op==0 ? "add" : "roll"));\r
- for (int field=0; field < cal.getFieldCount(); ++field) {\r
- if (field != Calendar.ZONE_OFFSET &&\r
- field != Calendar.DST_OFFSET) {\r
- for (int j=0; j<fieldsList.length; ++j) {\r
- int fields[] = fieldsList[j];\r
- cal.clear();\r
- cal.set(fields[0], fields[1], fields[2],\r
- fields[3], fields[4], fields[5]);\r
- cal.set(Calendar.MILLISECOND, fields[6]);\r
- cal.setMinimalDaysInFirstWeek(1);\r
- for (int i = 0; i < 2*limit; i++) {\r
- if (op == 0) {\r
- cal.add(field, i < limit ? 1 : -1);\r
- } else {\r
- cal.roll(field, i < limit ? 1 : -1);\r
- }\r
- }\r
- if (cal.get(Calendar.YEAR) != fields[0] ||\r
- cal.get(Calendar.MONTH) != fields[1] ||\r
- cal.get(Calendar.DATE) != fields[2] ||\r
- cal.get(Calendar.HOUR_OF_DAY) != fields[3] ||\r
- cal.get(Calendar.MINUTE) != fields[4] ||\r
- cal.get(Calendar.SECOND) != fields[5] ||\r
- cal.get(Calendar.MILLISECOND) != fields[6]) {\r
- errln("Field " + field +\r
- " (" + FIELD_NAME[field] +\r
- ") FAIL, expected " +\r
- fields[0] +\r
- "/" + (fields[1] + 1) +\r
- "/" + fields[2] +\r
- " " + fields[3] +\r
- ":" + fields[4] +\r
- ":" + fields[5] +\r
- "." + fields[6] +\r
- ", got " + cal.get(Calendar.YEAR) +\r
- "/" + (cal.get(Calendar.MONTH) + 1) +\r
- "/" + cal.get(Calendar.DATE) +\r
- " " + cal.get(Calendar.HOUR_OF_DAY) +\r
- ":" + cal.get(Calendar.MINUTE) +\r
- ":" + cal.get(Calendar.SECOND) +\r
- "." + cal.get(Calendar.MILLISECOND));\r
- cal.clear();\r
- cal.set(fields[0], fields[1], fields[2],\r
- fields[3], fields[4], fields[5]);\r
- cal.set(Calendar.MILLISECOND, fields[6]);\r
- logln("Start date: " + cal.get(Calendar.YEAR) +\r
- "/" + (cal.get(Calendar.MONTH) + 1) +\r
- "/" + cal.get(Calendar.DATE) +\r
- " " + cal.get(Calendar.HOUR_OF_DAY) +\r
- ":" + cal.get(Calendar.MINUTE) +\r
- ":" + cal.get(Calendar.SECOND) +\r
- "." + cal.get(Calendar.MILLISECOND));\r
- long prev = cal.getTime().getTime();\r
- for (int i = 0; i < 2*limit; i++) {\r
- if (op == 0) {\r
- cal.add(field, i < limit ? 1 : -1);\r
- } else {\r
- cal.roll(field, i < limit ? 1 : -1);\r
- }\r
- long t = cal.getTime().getTime();\r
- long delta = t - prev;\r
- prev = t;\r
- logln((op == 0 ? "add(" : "roll(") + FIELD_NAME[field] +\r
- (i < limit ? ", +1) => " : ", -1) => ") +\r
- cal.get(Calendar.YEAR) +\r
- "/" + (cal.get(Calendar.MONTH) + 1) +\r
- "/" + cal.get(Calendar.DATE) +\r
- " " + cal.get(Calendar.HOUR_OF_DAY) +\r
- ":" + cal.get(Calendar.MINUTE) +\r
- ":" + cal.get(Calendar.SECOND) +\r
- "." + cal.get(Calendar.MILLISECOND) +\r
- " delta=" + delta + " ms");\r
- }\r
- }\r
- }\r
- }\r
- }\r
- }\r
- }\r
-\r
- public void Test4174361() {\r
- GregorianCalendar calendar = new GregorianCalendar(1996, 1, 29);\r
-\r
- calendar.add(Calendar.MONTH, 10); \r
- //Date date1 = calendar.getTime();\r
- //date1 = null;\r
- int d1 = calendar.get(Calendar.DAY_OF_MONTH);\r
-\r
- calendar = new GregorianCalendar(1996, 1, 29);\r
- calendar.add(Calendar.MONTH, 11); \r
- //Date date2 = calendar.getTime();\r
- //date2 = null;\r
- int d2 = calendar.get(Calendar.DAY_OF_MONTH);\r
-\r
- if (d1 != d2) {\r
- errln("adding months to Feb 29 broken");\r
- }\r
- }\r
-\r
- /**\r
- * Calendar does not update field values when setTimeZone is called.\r
- */\r
- public void Test4177484() {\r
- TimeZone PST = TimeZone.getTimeZone("PST");\r
- TimeZone EST = TimeZone.getTimeZone("EST");\r
-\r
- Calendar cal = Calendar.getInstance(PST, Locale.US);\r
- cal.clear();\r
- cal.set(1999, 3, 21, 15, 5, 0); // Arbitrary\r
- int h1 = cal.get(Calendar.HOUR_OF_DAY);\r
- cal.setTimeZone(EST);\r
- int h2 = cal.get(Calendar.HOUR_OF_DAY);\r
- if (h1 == h2) {\r
- errln("FAIL: Fields not updated after setTimeZone");\r
- }\r
-\r
- // getTime() must NOT change when time zone is changed.\r
- // getTime() returns zone-independent time in ms.\r
- cal.clear();\r
- cal.setTimeZone(PST);\r
- cal.set(Calendar.HOUR_OF_DAY, 10);\r
- Date pst10 = cal.getTime();\r
- cal.setTimeZone(EST);\r
- Date est10 = cal.getTime();\r
- if (!pst10.equals(est10)) {\r
- errln("FAIL: setTimeZone changed time");\r
- }\r
- }\r
-\r
- /**\r
- * Week of year is wrong at the start and end of the year.\r
- */\r
- public void Test4197699() {\r
- GregorianCalendar cal = new GregorianCalendar();\r
- cal.setFirstDayOfWeek(Calendar.MONDAY);\r
- cal.setMinimalDaysInFirstWeek(4);\r
- DateFormat fmt = new SimpleDateFormat("E dd MMM yyyy 'DOY='D 'WOY='w");\r
- fmt.setCalendar(cal);\r
-\r
- int[] DATA = {\r
- 2000, Calendar.JANUARY, 1, 52,\r
- 2001, Calendar.DECEMBER, 31, 1,\r
- };\r
-\r
- for (int i=0; i<DATA.length; ) {\r
- cal.set(DATA[i++], DATA[i++], DATA[i++]);\r
- int expWOY = DATA[i++];\r
- int actWOY = cal.get(Calendar.WEEK_OF_YEAR);\r
- if (expWOY == actWOY) {\r
- logln("Ok: " + fmt.format(cal.getTime()));\r
- } else {\r
- errln("FAIL: " + fmt.format(cal.getTime())\r
- + ", expected WOY=" + expWOY);\r
- cal.add(Calendar.DATE, -8);\r
- for (int j=0; j<14; ++j) {\r
- cal.add(Calendar.DATE, 1);\r
- logln(fmt.format(cal.getTime()));\r
- }\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Calendar DAY_OF_WEEK_IN_MONTH fields->time broken. The problem is in the\r
- * field disambiguation code in GregorianCalendar. This code is supposed to\r
- * choose the most recent set of fields among the following:\r
- * \r
- * MONTH + DAY_OF_MONTH MONTH + WEEK_OF_MONTH + DAY_OF_WEEK MONTH +\r
- * DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK DAY_OF_YEAR WEEK_OF_YEAR + DAY_OF_WEEK\r
- */\r
- public void Test4209071() {\r
- Calendar cal = Calendar.getInstance(Locale.US);\r
-\r
- // General field setting test\r
- int Y = 1995;\r
- \r
- Date d[] = new Date[13];\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.clear();\r
- tempcal.set(Y, Calendar.JANUARY, 1);\r
- d[0] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.MARCH, 1);\r
- d[1] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.JANUARY, 4);\r
- d[2] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.JANUARY, 18);\r
- d[3] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.JANUARY, 18);\r
- d[4] = tempcal.getTime();\r
- tempcal.set(Y-1, Calendar.DECEMBER, 22);\r
- d[5] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.JANUARY, 26);\r
- d[6] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.JANUARY, 26);\r
- d[7] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.MARCH, 1);\r
- d[8] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.OCTOBER, 6);\r
- d[9] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.OCTOBER, 13);\r
- d[10] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.AUGUST, 10);\r
- d[11] = tempcal.getTime();\r
- tempcal.set(Y, Calendar.DECEMBER, 7);\r
- d[12] = tempcal.getTime();\r
-\r
- Object[] FIELD_DATA = {\r
- // Add new test cases as needed.\r
-\r
- // 0\r
- new int[] {}, d[0],\r
- // 1\r
- new int[] { Calendar.MONTH, Calendar.MARCH }, d[1],\r
- // 2\r
- new int[] { Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY }, d[2],\r
- // 3\r
- new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,\r
- Calendar.DAY_OF_MONTH, 18, }, d[3],\r
- // 4\r
- new int[] { Calendar.DAY_OF_MONTH, 18,\r
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[4],\r
- // 5 (WOM -1 is in previous month)\r
- new int[] { Calendar.DAY_OF_MONTH, 18,\r
- Calendar.WEEK_OF_MONTH, -1,\r
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[5],\r
- // 6\r
- new int[] { Calendar.DAY_OF_MONTH, 18,\r
- Calendar.WEEK_OF_MONTH, 4,\r
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[6],\r
- // 7 (DIM -1 is in same month)\r
- new int[] { Calendar.DAY_OF_MONTH, 18,\r
- Calendar.DAY_OF_WEEK_IN_MONTH, -1,\r
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[7],\r
- // 8\r
- new int[] { Calendar.WEEK_OF_YEAR, 9,\r
- Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY, }, d[8],\r
- // 9\r
- new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
- Calendar.DAY_OF_WEEK_IN_MONTH, 1,\r
- Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[9],\r
- // 10\r
- new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
- Calendar.WEEK_OF_MONTH, 2,\r
- Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[10],\r
- // 11\r
- new int[] { Calendar.MONTH, Calendar.OCTOBER,\r
- Calendar.DAY_OF_MONTH, 15,\r
- Calendar.DAY_OF_YEAR, 222, }, d[11],\r
- // 12\r
- new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,\r
- Calendar.MONTH, Calendar.DECEMBER, }, d[12],\r
- };\r
-\r
- for (int i=0; i<FIELD_DATA.length; i+=2) {\r
- int[] fields = (int[]) FIELD_DATA[i];\r
- Date exp = (Date) FIELD_DATA[i+1];\r
- \r
- cal.clear();\r
- cal.set(Calendar.YEAR, Y);\r
- for (int j=0; j<fields.length; j+=2) {\r
- cal.set(fields[j], fields[j+1]);\r
- }\r
- \r
- Date act = cal.getTime();\r
- if (!act.equals(exp)) {\r
- errln("FAIL: Test " + (i/2) + " got " + act +\r
- ", want " + exp +\r
- " (see test/java/util/Calendar/CalendarRegression.java");\r
- }\r
- }\r
-\r
- tempcal.set(1997, Calendar.JANUARY, 5);\r
- d[0] = tempcal.getTime();\r
- tempcal.set(1997, Calendar.JANUARY, 26);\r
- d[1] = tempcal.getTime();\r
- tempcal.set(1997, Calendar.FEBRUARY, 23);\r
- d[2] = tempcal.getTime();\r
- tempcal.set(1997, Calendar.JANUARY, 26);\r
- d[3] = tempcal.getTime();\r
- tempcal.set(1997, Calendar.JANUARY, 5);\r
- d[4] = tempcal.getTime();\r
- tempcal.set(1996, Calendar.DECEMBER, 8);\r
- d[5] = tempcal.getTime();\r
- // Test specific failure reported in bug\r
- Object[] DATA = { \r
- new Integer(1), d[0], new Integer(4), d[1],\r
- new Integer(8), d[2], new Integer(-1), d[3],\r
- new Integer(-4), d[4], new Integer(-8), d[5],\r
- };\r
- for (int i=0; i<DATA.length; i+=2) {\r
- cal.clear();\r
- cal.set(Calendar.DAY_OF_WEEK_IN_MONTH,\r
- ((Number) DATA[i]).intValue());\r
- cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);\r
- cal.set(Calendar.MONTH, Calendar.JANUARY);\r
- cal.set(Calendar.YEAR, 1997);\r
- Date actual = cal.getTime();\r
- if (!actual.equals(DATA[i+1])) {\r
- errln("FAIL: Sunday " + DATA[i] +\r
- " of Jan 1997 -> " + actual +\r
- ", want " + DATA[i+1]);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * WEEK_OF_YEAR computed incorrectly. A failure of this test can indicate a\r
- * problem in several different places in the\r
- */\r
- public void Test4288792() throws Exception \r
- {\r
- TimeZone savedTZ = TimeZone.getDefault();\r
- TimeZone.setDefault(TimeZone.getTimeZone("GMT"));\r
- GregorianCalendar cal = new GregorianCalendar();\r
- \r
- for (int i = 1900; i < 2100; i++) {\r
- for (int j1 = 1; j1 <= 7; j1++) {\r
- // Loop for MinimalDaysInFirstWeek: 1..7\r
- for (int j = Calendar.SUNDAY; j <= Calendar.SATURDAY; j++) {\r
- // Loop for FirstDayOfWeek: SUNDAY..SATURDAY\r
- cal.clear();\r
- cal.setMinimalDaysInFirstWeek(j1);\r
- cal.setFirstDayOfWeek(j);\r
- // Set the calendar to the first day of the last week\r
- // of the year. This may overlap some of the start of\r
- // the next year; that is, the last week of 1999 may\r
- // include some of January 2000. Use the add() method\r
- // to advance through the week. For each day, call\r
- // get(WEEK_OF_YEAR). The result should be the same\r
- // for the whole week. Note that a bug in\r
- // getActualMaximum() will break this test.\r
- cal.set(Calendar.YEAR, i);\r
- int maxWeek = cal.getActualMaximum(Calendar.WEEK_OF_YEAR);\r
- cal.set(Calendar.WEEK_OF_YEAR, maxWeek);\r
- cal.set(Calendar.DAY_OF_WEEK, j);\r
- for (int k = 1; k < 7; k++) {\r
- cal.add(Calendar.DATE, 1);\r
- int WOY = cal.get(Calendar.WEEK_OF_YEAR);\r
- if (WOY != maxWeek) {\r
- errln(cal.getTime() + ",got=" + WOY\r
- + ",expected=" + maxWeek \r
- + ",min=" + j1 + ",first=" + j);\r
- }\r
- }\r
- // Now advance the calendar one more day. This should\r
- // put it at the first day of week 1 of the next year.\r
- cal.add(Calendar.DATE, 1);\r
- int WOY = cal.get(Calendar.WEEK_OF_YEAR);\r
- if (WOY != 1) {\r
- errln(cal.getTime() + ",got=" + WOY \r
- + ",expected=1,min=" + j1 + ",first" + j);\r
- }\r
- }\r
- }\r
- }\r
- TimeZone.setDefault(savedTZ);\r
- }\r
-\r
- /**\r
- * Test fieldDifference().\r
- */\r
- public void TestJ438() throws Exception {\r
- int DATA[] = {\r
- 2000, Calendar.JANUARY, 20, 2010, Calendar.JUNE, 15,\r
- 2010, Calendar.JUNE, 15, 2000, Calendar.JANUARY, 20,\r
- 1964, Calendar.SEPTEMBER, 7, 1999, Calendar.JUNE, 4,\r
- 1999, Calendar.JUNE, 4, 1964, Calendar.SEPTEMBER, 7,\r
- };\r
- Calendar cal = Calendar.getInstance(Locale.US);\r
- for (int i=0; i<DATA.length; i+=6) {\r
- int y1 = DATA[i];\r
- int m1 = DATA[i+1];\r
- int d1 = DATA[i+2];\r
- int y2 = DATA[i+3];\r
- int m2 = DATA[i+4];\r
- int d2 = DATA[i+5];\r
-\r
- cal.clear();\r
- cal.set(y1, m1, d1);\r
- Date date1 = cal.getTime();\r
- cal.set(y2, m2, d2);\r
- Date date2 = cal.getTime();\r
-\r
- cal.setTime(date1);\r
- int dy = cal.fieldDifference(date2, Calendar.YEAR);\r
- int dm = cal.fieldDifference(date2, Calendar.MONTH);\r
- int dd = cal.fieldDifference(date2, Calendar.DATE);\r
-\r
- logln("" + date2 + " - " + date1 + " = " +\r
- dy + "y " + dm + "m " + dd + "d");\r
-\r
- cal.setTime(date1);\r
- cal.add(Calendar.YEAR, dy);\r
- cal.add(Calendar.MONTH, dm);\r
- cal.add(Calendar.DATE, dd);\r
- Date date22 = cal.getTime();\r
- if (!date2.equals(date22)) {\r
- errln("FAIL: " + date1 + " + " +\r
- dy + "y " + dm + "m " + dd + "d = " +\r
- date22 + ", exp " + date2);\r
- } else {\r
- logln("Ok: " + date1 + " + " +\r
- dy + "y " + dm + "m " + dd + "d = " +\r
- date22);\r
- }\r
- }\r
- }\r
- \r
- public void TestT5555() throws Exception\r
- {\r
- Calendar cal = Calendar.getInstance();\r
- \r
- // Set date to Wednesday, February 21, 2007\r
- cal.set(2007, Calendar.FEBRUARY, 21);\r
-\r
- try {\r
- // Advance month by three years\r
- cal.add(Calendar.MONTH, 36);\r
- \r
- // Move to last Wednesday of month.\r
- cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);\r
- \r
- cal.getTime();\r
- } catch (Exception e) {\r
- errln("Got an exception calling getTime().");\r
- }\r
- \r
- int yy, mm, dd, ee;\r
- \r
- yy = cal.get(Calendar.YEAR);\r
- mm = cal.get(Calendar.MONTH);\r
- dd = cal.get(Calendar.DATE);\r
- ee = cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);\r
- \r
- if (yy != 2010 || mm != Calendar.FEBRUARY || dd != 24 || ee != Calendar.WEDNESDAY) {\r
- errln("Got date " + yy + "/" + (mm + 1) + "/" + dd + ", expected 2010/2/24");\r
- }\r
- }\r
-\r
- /**\r
- * Set behavior of DST_OFFSET field. ICU4J Jitterbug 9.\r
- */\r
- public void TestJ9() {\r
- int HOURS = 60*60*1000;\r
- Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("PST"),\r
- Locale.US);\r
-\r
- final int END_FIELDS = 0x1234;\r
-\r
- int[] DATA = {\r
- // With no explicit ZONE/DST expect 12:00 am\r
- Calendar.MONTH, Calendar.JUNE,\r
- END_FIELDS,\r
- 0, 0, // expected hour, min\r
-\r
- // Normal ZONE/DST for June 1 Pacific is 8:00/1:00\r
- Calendar.MONTH, Calendar.JUNE,\r
- Calendar.ZONE_OFFSET, -8*HOURS,\r
- Calendar.DST_OFFSET, HOURS,\r
- END_FIELDS,\r
- 0, 0, // expected hour, min\r
-\r
- // With ZONE/DST of 8:00/0:30 expect time of 12:30 am\r
- Calendar.MONTH, Calendar.JUNE,\r
- Calendar.ZONE_OFFSET, -8*HOURS,\r
- Calendar.DST_OFFSET, HOURS/2,\r
- END_FIELDS,\r
- 0, 30, // expected hour, min\r
-\r
- // With ZONE/DST of 8:00/UNSET expect time of 1:00 am\r
- Calendar.MONTH, Calendar.JUNE,\r
- Calendar.ZONE_OFFSET, -8*HOURS,\r
- END_FIELDS,\r
- 1, 0, // expected hour, min\r
-\r
- // With ZONE/DST of UNSET/0:30 expect 4:30 pm (day before)\r
- Calendar.MONTH, Calendar.JUNE,\r
- Calendar.DST_OFFSET, HOURS/2,\r
- END_FIELDS,\r
- 16, 30, // expected hour, min\r
- };\r
-\r
- for (int i=0; i<DATA.length; ) {\r
- int start = i;\r
- cal.clear();\r
-\r
- // Set fields\r
- while (DATA[i] != END_FIELDS) {\r
- cal.set(DATA[i++], DATA[i++]);\r
- }\r
- ++i; // skip over END_FIELDS\r
-\r
- // Get hour/minute\r
- int h = cal.get(Calendar.HOUR_OF_DAY);\r
- int m = cal.get(Calendar.MINUTE);\r
-\r
- // Check\r
- if (h != DATA[i] || m != DATA[i+1]) {\r
- errln("Fail: expected " + DATA[i] + ":" + DATA[i+1] +\r
- ", got " + h + ":" + m + " after:");\r
- while (DATA[start] != END_FIELDS) {\r
- logln("set(" + FIELD_NAME[DATA[start++]] +\r
- ", " + DATA[start++] + ");");\r
- }\r
- }\r
-\r
- i += 2; // skip over expected hour, min\r
- }\r
- }\r
-\r
- /**\r
- * DateFormat class mistakes date style and time style as follows: -\r
- * DateFormat.getDateTimeInstance takes date style as time style, and time\r
- * style as date style - If a Calendar is passed to\r
- * DateFormat.getDateInstance, it returns time instance - If a Calendar is\r
- * passed to DateFormat.getTimeInstance, it returns date instance\r
- */\r
- public void TestDateFormatFactoryJ26() {\r
- TimeZone zone = TimeZone.getDefault();\r
- try {\r
- Locale loc = Locale.US;\r
- TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));\r
- java.util.Calendar tempcal = java.util.Calendar.getInstance();\r
- tempcal.set(2001, Calendar.APRIL, 5, 17, 43, 53);\r
- Date date = tempcal.getTime();\r
- Calendar cal = Calendar.getInstance(loc);\r
- Object[] DATA = {\r
- DateFormat.getDateInstance(DateFormat.SHORT, loc),\r
- "DateFormat.getDateInstance(DateFormat.SHORT, loc)",\r
- "4/5/01",\r
-\r
- DateFormat.getTimeInstance(DateFormat.SHORT, loc),\r
- "DateFormat.getTimeInstance(DateFormat.SHORT, loc)",\r
- "5:43 PM",\r
-\r
- DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc),\r
- "DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc)",\r
- "Thursday, April 5, 2001 5:43 PM",\r
-\r
- DateFormat.getDateInstance(cal, DateFormat.SHORT, loc),\r
- "DateFormat.getDateInstance(cal, DateFormat.SHORT, loc)",\r
- "4/5/01",\r
-\r
- DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc),\r
- "DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc)",\r
- "5:43 PM",\r
-\r
- DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc),\r
- "DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc)",\r
- "Thursday, April 5, 2001 5:43 PM",\r
- \r
- cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc),\r
- "cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc)",\r
- "4/5/01 5:43:53 PM Pacific Daylight Time",\r
-\r
- cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc),\r
- "cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc)",\r
- "Thursday, April 5, 2001 5:43 PM",\r
- };\r
- for (int i=0; i<DATA.length; i+=3) {\r
- DateFormat df = (DateFormat) DATA[i];\r
- String desc = (String) DATA[i+1];\r
- String exp = (String) DATA[i+2];\r
- String got = df.format(date);\r
- if (got.equals(exp)) {\r
- logln("Ok: " + desc + " => " + got);\r
- } else {\r
- errln("FAIL: " + desc + " => " + got + ", expected " + exp);\r
- }\r
- }\r
- } finally {\r
- TimeZone.setDefault(zone);\r
- }\r
- }\r
-\r
- public void TestRegistration() {\r
- /*\r
- * Set names = Calendar.getCalendarFactoryNames();\r
- * \r
- * TimeZone tz = TimeZone.getDefault(); Locale loc =\r
- * Locale.getDefault(); Iterator iter = names.iterator(); while\r
- * (iter.hasNext()) { String name = (String)iter.next(); logln("Testing\r
- * factory: " + name);\r
- * \r
- * Calendar cal = Calendar.getInstance(tz, loc, name); logln("Calendar\r
- * class: " + cal.getClass());\r
- * \r
- * DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG,\r
- * DateFormat.LONG, loc);\r
- * \r
- * logln("Date: " + fmt.format(cal.getTime())); }\r
- * // register new default for our locale logln("\nTesting\r
- * registration"); loc = new Locale("en", "US"); Object key =\r
- * Calendar.register(JapaneseCalendar.factory(), loc, true);\r
- * \r
- * loc = new Locale("en", "US", "TEST"); Calendar cal =\r
- * Calendar.getInstance(loc); logln("Calendar class: " +\r
- * cal.getClass()); DateFormat fmt =\r
- * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
- * logln("Date: " + fmt.format(cal.getTime()));\r
- * // force to use other default anyway logln("\nOverride\r
- * registration"); cal = Calendar.getInstance(tz, loc, "Gregorian"); fmt =\r
- * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
- * logln("Date: " + fmt.format(cal.getTime()));\r
- * // unregister default logln("\nUnregistration"); logln("Unregister\r
- * returned: " + Calendar.unregister(key)); cal =\r
- * Calendar.getInstance(tz, loc, "Gregorian"); fmt =\r
- * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);\r
- * logln("Date: " + fmt.format(cal.getTime()));\r
- */\r
- }\r
-\r
- /**\r
- * test serialize-and-modify.\r
- * @throws ClassNotFoundException \r
- */\r
- public void TestSerialization3474() {\r
- try {\r
- ByteArrayOutputStream icuStream = new ByteArrayOutputStream();\r
- \r
- logln("icu Calendar");\r
- \r
- com.ibm.icu.util.GregorianCalendar icuCalendar =\r
- new com.ibm.icu.util.GregorianCalendar();\r
- \r
- icuCalendar.setTimeInMillis(1187912555931L);\r
- long expectMillis = 1187912520931L; // with seconds (not ms) cleared.\r
- \r
- logln("instantiated: "+icuCalendar);\r
- logln("getMillis: "+icuCalendar.getTimeInMillis());\r
- icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);\r
- logln("setSecond=0: "+icuCalendar);\r
- {\r
- long gotMillis = icuCalendar.getTimeInMillis();\r
- if(gotMillis != expectMillis) {\r
- errln("expect millis "+expectMillis+" but got "+gotMillis);\r
- } else {\r
- logln("getMillis: "+gotMillis);\r
- }\r
- }\r
- ObjectOutputStream icuOut =\r
- new ObjectOutputStream(icuStream);\r
- icuOut.writeObject(icuCalendar);\r
- icuOut.flush();\r
- icuOut.close();\r
- \r
- ObjectInputStream icuIn =\r
- new ObjectInputStream(new ByteArrayInputStream(icuStream.toByteArray()));\r
- icuCalendar = null;\r
- icuCalendar = (com.ibm.icu.util.GregorianCalendar)icuIn.readObject();\r
- \r
- logln("serialized back in: "+icuCalendar);\r
- {\r
- long gotMillis = icuCalendar.getTimeInMillis();\r
- if(gotMillis != expectMillis) {\r
- errln("expect millis "+expectMillis+" but got "+gotMillis);\r
- } else {\r
- logln("getMillis: "+gotMillis);\r
- }\r
- }\r
- \r
- icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);\r
- \r
- logln("setSecond=0: "+icuCalendar);\r
- {\r
- long gotMillis = icuCalendar.getTimeInMillis();\r
- if(gotMillis != expectMillis) {\r
- errln("expect millis "+expectMillis+" after stream and setSecond but got "+gotMillis);\r
- } else {\r
- logln("getMillis after stream and setSecond: "+gotMillis);\r
- }\r
- }\r
- } catch(IOException e) {\r
- errln(e.toString());\r
- e.printStackTrace();\r
- } catch(ClassNotFoundException cnf) {\r
- errln(cnf.toString());\r
- cnf.printStackTrace();\r
- }\r
-\r
- // JDK works correctly, etc etc. \r
-// ByteArrayOutputStream jdkStream = new ByteArrayOutputStream();\r
-\r
-// logln("\nSUN Calendar");\r
-// \r
-// java.util.GregorianCalendar sunCalendar =\r
-// new java.util.GregorianCalendar();\r
-// \r
-// logln("instanzieren: "+sunCalendar);\r
-// logln("getMillis: "+sunCalendar.getTimeInMillis());\r
-// sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);\r
-// logln("setSecond=0: "+sunCalendar);\r
-// logln("getMillis: "+sunCalendar.getTimeInMillis());\r
-// \r
-// ObjectOutputStream sunOut =\r
-// new ObjectOutputStream(jdkStream);\r
-// sunOut.writeObject(sunCalendar);\r
-// sunOut.flush();\r
-// sunOut.close();\r
-// \r
-// ObjectInputStream sunIn =\r
-// new ObjectInputStream(new ByteArrayInputStream(jdkStream.toByteArray()));\r
-// sunCalendar = null;\r
-// sunCalendar = (java.util.GregorianCalendar)sunIn.readObject();\r
-// \r
-// logln("serialized: "+sunCalendar);\r
-// logln("getMillis: "+sunCalendar.getTimeInMillis());\r
-// \r
-// sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);\r
-// logln("setSecond=0: "+sunCalendar);\r
-// logln("getMillis: "+sunCalendar.getTimeInMillis());\r
- \r
- }\r
-\r
- public void TestYearJump3279() {\r
- final long time = 1041148800000L;\r
- Calendar c = new GregorianCalendar();\r
- DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.US);\r
-\r
- c.setTimeInMillis(time);\r
- int year1 = c.get(Calendar.YEAR);\r
- \r
- logln("time: " + fmt.format(new Date(c.getTimeInMillis())));\r
-\r
- logln("setting DOW to " + c.getFirstDayOfWeek());\r
- c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());\r
- logln("week: " + c.getTime());\r
- logln("week adjust: " + fmt.format(new Date(c.getTimeInMillis())));\r
- int year2 = c.get(Calendar.YEAR);\r
- \r
- if(year1 != year2) {\r
- errln("Error: adjusted day of week, and year jumped from " + year1 + " to " + year2);\r
- } else {\r
- logln("Year remained " + year2 + " - PASS.");\r
- }\r
- }\r
-\r
- public void TestGetKeywordValuesForLocale(){\r
-\r
- final String[][] PREFERRED = {\r
- {"root", "gregorian"},\r
- {"und", "gregorian"},\r
- {"en_US", "gregorian"},\r
- {"en_029", "gregorian"},\r
- {"th_TH", "buddhist", "gregorian"},\r
- {"und_TH", "buddhist", "gregorian"},\r
- {"en_TH", "buddhist", "gregorian"},\r
- {"he_IL", "gregorian", "hebrew", "islamic", "islamic-civil"},\r
- {"ar_EG", "gregorian", "coptic", "islamic", "islamic-civil"},\r
- {"ja", "gregorian", "japanese"},\r
- {"ps_Guru_IN", "gregorian", "indian"},\r
- {"th@calendar=gregorian", "buddhist", "gregorian"},\r
- {"en@calendar=islamic", "gregorian"},\r
- {"zh_TW", "gregorian", "roc", "chinese"},\r
- {"ar_IR", "gregorian", "persian", "islamic", "islamic-civil"},\r
- };\r
-\r
- String[] ALL = Calendar.getKeywordValuesForLocale("calendar", ULocale.getDefault(), false);\r
- HashSet ALLSET = new HashSet();\r
- for (int i = 0; i < ALL.length; i++) {\r
- ALLSET.add(ALL[i]);\r
- }\r
-\r
- for (int i = 0; i < PREFERRED.length; i++) {\r
- ULocale loc = new ULocale(PREFERRED[i][0]);\r
- String[] expected = new String[PREFERRED[i].length - 1];\r
- System.arraycopy(PREFERRED[i], 1, expected, 0, expected.length);\r
-\r
- String[] pref = Calendar.getKeywordValuesForLocale("calendar", loc, true);\r
- boolean matchPref = false;\r
- if (pref.length == expected.length) {\r
- matchPref = true;\r
- for (int j = 0; j < pref.length; j++) {\r
- if (!pref[j].equals(expected[j])) {\r
- matchPref = false;\r
- }\r
- }\r
- }\r
- if (!matchPref) {\r
- errln("FAIL: Preferred values for locale " + loc \r
- + " got:" + Utility.arrayToString(pref) + " expected:" + Utility.arrayToString(expected));\r
- }\r
-\r
- String[] all = Calendar.getKeywordValuesForLocale("calendar", loc, false);\r
- boolean matchAll = false;\r
- if (all.length == ALLSET.size()) {\r
- matchAll = true;\r
- for (int j = 0; j < all.length; j++) {\r
- if (!ALLSET.contains(all[j])) {\r
- matchAll = false;\r
- break;\r
- }\r
- }\r
- }\r
- if (!matchAll) {\r
- errln("FAIL: All values for locale " + loc\r
- + " got:" + Utility.arrayToString(all)); \r
- }\r
- }\r
- }\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 java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.MissingResourceException;
+
+import com.ibm.icu.impl.Utility;
+import com.ibm.icu.text.DateFormat;
+import com.ibm.icu.text.NumberFormat;
+import com.ibm.icu.text.SimpleDateFormat;
+import com.ibm.icu.util.Calendar;
+import com.ibm.icu.util.GregorianCalendar;
+import com.ibm.icu.util.SimpleTimeZone;
+import com.ibm.icu.util.TimeZone;
+import com.ibm.icu.util.ULocale;
+
+/**
+ * @test 1.32 99/11/14
+ * @bug 4031502 4035301 4040996 4051765 4059654 4061476 4070502 4071197 4071385
+ * 4073929 4083167 4086724 4092362 4095407 4096231 4096539 4100311 4103271
+ * 4106136 4108764 4114578 4118384 4125881 4125892 4136399 4141665 4142933
+ * 4145158 4145983 4147269 4149677 4162587 4165343 4166109 4167060 4173516
+ * 4174361 4177484 4197699 4209071 4288792
+ */
+public class CalendarRegression extends com.ibm.icu.dev.test.TestFmwk {
+
+ public static void main(String[] args) throws Exception {
+ new CalendarRegression().run(args);
+ }
+ 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"
+ };
+
+
+ /*
+ Synopsis: java.sql.Timestamp constructor works wrong on Windows 95
+
+ ==== Here is the test ====
+ public static void main (String args[]) {
+ java.sql.Timestamp t= new java.sql.Timestamp(0,15,5,5,8,13,123456700);
+ logln("expected=1901-04-05 05:08:13.1234567");
+ logln(" result="+t);
+ }
+
+ ==== Here is the output of the test on Solaris or NT ====
+ expected=1901-04-05 05:08:13.1234567
+ result=1901-04-05 05:08:13.1234567
+
+ ==== Here is the output of the test on Windows95 ====
+ expected=1901-04-05 05:08:13.1234567
+ result=1901-04-05 06:08:13.1234567
+ */
+
+ public void Test4031502() {
+ try{
+ // This bug actually occurs on Windows NT as well, and doesn't
+ // require the host zone to be set; it can be set in Java.
+ String[] ids = TimeZone.getAvailableIDs();
+ boolean bad = false;
+ for (int i=0; i<ids.length; ++i) {
+ TimeZone zone = TimeZone.getTimeZone(ids[i]);
+ GregorianCalendar cal = new GregorianCalendar(zone);
+ cal.clear();
+ cal.set(1900, 15, 5, 5, 8, 13);
+ if (cal.get(Calendar.HOUR) != 5) {
+ logln("Fail: " + zone.getID() + " " +
+ zone.useDaylightTime() + "; DST_OFFSET = " +
+ cal.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +
+ cal.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +
+ zone.getRawOffset() / (60*60*1000.0) +
+ "; HOUR = " + cal.get(Calendar.HOUR));
+ cal.clear();
+ cal.set(1900, 15, 5, 5, 8, 13);
+ if (cal.get(Calendar.HOUR) != 5) {
+ logln("Fail: " + zone.getID() + " " +
+ zone.useDaylightTime() + "; DST_OFFSET = " +
+ cal.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +
+ cal.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +
+ zone.getRawOffset() / (60*60*1000.0) +
+ "; HOUR = " + cal.get(Calendar.HOUR));
+ cal.clear();
+ cal.set(1900, 15, 5, 5, 8, 13);
+ logln("ms = " + cal.getTime() + " (" + cal.getTime().getTime() + ")");
+ cal.get(Calendar.HOUR);
+ java.util.GregorianCalendar cal2 = new java.util.GregorianCalendar(java.util.TimeZone.getTimeZone(ids[i]));
+ cal2.clear();
+ cal2.set(1900, 15, 5, 5, 8, 13);
+ cal2.get(Calendar.HOUR);
+ logln("java.util.GC: " + zone.getID() + " " +
+ zone.useDaylightTime() + "; DST_OFFSET = " +
+ cal2.get(Calendar.DST_OFFSET) / (60*60*1000.0) + "; ZONE_OFFSET = " +
+ cal2.get(Calendar.ZONE_OFFSET) / (60*60*1000.0) + "; getRawOffset() = " +
+ zone.getRawOffset() / (60*60*1000.0) +
+ "; HOUR = " + cal.get(Calendar.HOUR));
+ logln("ms = " + cal2.getTime() + " (" + cal2.getTime().getTime() + ")");
+ bad = true;
+ } else if (false) { // Change to true to debug
+ logln("OK: " + zone.getID() + " " +
+ zone.useDaylightTime() + " " +
+ cal.get(Calendar.DST_OFFSET) / (60*60*1000) + " " +
+ zone.getRawOffset() / (60*60*1000) +
+ ": HOUR = " + cal.get(Calendar.HOUR));
+ }
+ }
+ if (bad) errln("TimeZone problems with GC");
+ }
+ } catch (MissingResourceException e) {
+ warnln("Could not load data. "+ e.getMessage());
+ }
+ }
+
+ public void Test4035301() {
+
+ try {
+ GregorianCalendar c = new GregorianCalendar(98, 8, 7);
+ GregorianCalendar d = new GregorianCalendar(98, 8, 7);
+ if (c.after(d) ||
+ c.after(c) ||
+ c.before(d) ||
+ c.before(c) ||
+ !c.equals(c) ||
+ !c.equals(d))
+ errln("Fail");
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ warnln("Could not load data. "+ e.getMessage());
+ }
+ }
+
+ public void Test4040996() {
+ try {
+ String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);
+ SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);
+ pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
+ pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
+ Calendar calendar = new GregorianCalendar(pdt);
+
+ calendar.set(Calendar.MONTH,3);
+ calendar.set(Calendar.DAY_OF_MONTH,18);
+ calendar.set(Calendar.SECOND, 30);
+
+ logln("MONTH: " + calendar.get(Calendar.MONTH));
+ logln("DAY_OF_MONTH: " +
+ calendar.get(Calendar.DAY_OF_MONTH));
+ logln("MINUTE: " + calendar.get(Calendar.MINUTE));
+ logln("SECOND: " + calendar.get(Calendar.SECOND));
+
+ calendar.add(Calendar.SECOND,6);
+ //This will print out todays date for MONTH and DAY_OF_MONTH
+ //instead of the date it was set to.
+ //This happens when adding MILLISECOND or MINUTE also
+ logln("MONTH: " + calendar.get(Calendar.MONTH));
+ logln("DAY_OF_MONTH: " +
+ calendar.get(Calendar.DAY_OF_MONTH));
+ logln("MINUTE: " + calendar.get(Calendar.MINUTE));
+ logln("SECOND: " + calendar.get(Calendar.SECOND));
+ if (calendar.get(Calendar.MONTH) != 3 ||
+ calendar.get(Calendar.DAY_OF_MONTH) != 18 ||
+ calendar.get(Calendar.SECOND) != 36)
+ errln("Fail: Calendar.add misbehaves");
+ } catch (Exception e) {
+ warnln("Could not load data. "+ e.getMessage());
+ }
+ }
+
+ public void Test4051765() {
+ try {
+ Calendar cal = Calendar.getInstance();
+ cal.setLenient(false);
+ cal.set(Calendar.DAY_OF_WEEK, 0);
+ try {
+ cal.getTime();
+ errln("Fail: DAY_OF_WEEK 0 should be disallowed");
+ }
+ catch (IllegalArgumentException e) {
+ return;
+ }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ warnln("Could not load data. "+ e.getMessage());
+ }
+ }
+
+ /*
+ * User error - no bug here public void Test4059524() { // Create calendar
+ * for April 10, 1997 GregorianCalendar calendar = new GregorianCalendar(); //
+ * print out a bunch of interesting things logln("ERA: " +
+ * calendar.get(calendar.ERA)); logln("YEAR: " +
+ * calendar.get(calendar.YEAR)); logln("MONTH: " +
+ * calendar.get(calendar.MONTH)); logln("WEEK_OF_YEAR: " +
+ * calendar.get(calendar.WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " +
+ * calendar.get(calendar.WEEK_OF_MONTH)); logln("DATE: " +
+ * calendar.get(calendar.DATE)); logln("DAY_OF_MONTH: " +
+ * calendar.get(calendar.DAY_OF_MONTH)); logln("DAY_OF_YEAR: " +
+ * calendar.get(calendar.DAY_OF_YEAR)); logln("DAY_OF_WEEK: " +
+ * calendar.get(calendar.DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " +
+ * calendar.get(calendar.DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " +
+ * calendar.get(calendar.AM_PM)); logln("HOUR: " +
+ * calendar.get(calendar.HOUR)); logln("HOUR_OF_DAY: " +
+ * calendar.get(calendar.HOUR_OF_DAY)); logln("MINUTE: " +
+ * calendar.get(calendar.MINUTE)); logln("SECOND: " +
+ * calendar.get(calendar.SECOND)); logln("MILLISECOND: " +
+ * calendar.get(calendar.MILLISECOND)); logln("ZONE_OFFSET: " +
+ * (calendar.get(calendar.ZONE_OFFSET)/(60*60*1000))); logln("DST_OFFSET: " +
+ * (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); calendar = new
+ * GregorianCalendar(1997,3,10); calendar.getTime(); logln("April 10,
+ * 1997"); logln("ERA: " + calendar.get(calendar.ERA)); logln("YEAR: " +
+ * calendar.get(calendar.YEAR)); logln("MONTH: " +
+ * calendar.get(calendar.MONTH)); logln("WEEK_OF_YEAR: " +
+ * calendar.get(calendar.WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " +
+ * calendar.get(calendar.WEEK_OF_MONTH)); logln("DATE: " +
+ * calendar.get(calendar.DATE)); logln("DAY_OF_MONTH: " +
+ * calendar.get(calendar.DAY_OF_MONTH)); logln("DAY_OF_YEAR: " +
+ * calendar.get(calendar.DAY_OF_YEAR)); logln("DAY_OF_WEEK: " +
+ * calendar.get(calendar.DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " +
+ * calendar.get(calendar.DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " +
+ * calendar.get(calendar.AM_PM)); logln("HOUR: " +
+ * calendar.get(calendar.HOUR)); logln("HOUR_OF_DAY: " +
+ * calendar.get(calendar.HOUR_OF_DAY)); logln("MINUTE: " +
+ * calendar.get(calendar.MINUTE)); logln("SECOND: " +
+ * calendar.get(calendar.SECOND)); logln("MILLISECOND: " +
+ * calendar.get(calendar.MILLISECOND)); logln("ZONE_OFFSET: " +
+ * (calendar.get(calendar.ZONE_OFFSET)/(60*60*1000))); // in hours
+ * logln("DST_OFFSET: " + (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); //
+ * in hours }
+ */
+
+ public void Test4059654() {
+ // try {
+ // work around bug for jdk1.4 on solaris 2.6, which uses funky
+ // timezone names
+ // jdk1.4.1 will drop support for 2.6 so we should be ok when it
+ // comes out
+ java.util.TimeZone javazone = java.util.TimeZone.getTimeZone("GMT");
+ TimeZone icuzone = TimeZone.getTimeZone("GMT");
+
+ GregorianCalendar gc = new GregorianCalendar(icuzone);
+
+ gc.set(1997, 3, 1, 15, 16, 17); // April 1, 1997
+
+ gc.set(Calendar.HOUR, 0);
+ gc.set(Calendar.AM_PM, Calendar.AM);
+ gc.set(Calendar.MINUTE, 0);
+ gc.set(Calendar.SECOND, 0);
+ gc.set(Calendar.MILLISECOND, 0);
+
+ Date cd = gc.getTime();
+ java.util.Calendar cal = java.util.Calendar.getInstance(javazone);
+ cal.clear();
+ cal.set(1997, 3, 1, 0, 0, 0);
+ Date exp = cal.getTime();
+ if (!cd.equals(exp))
+ errln("Fail: Calendar.set broken. Got " + cd + " Want " + exp);
+ // } catch (RuntimeException e) {
+ // TODO Auto-generated catch block
+ // e.printStackTrace();
+ // }
+ }
+
+ public void Test4061476() {
+ SimpleDateFormat fmt = new SimpleDateFormat("ddMMMyy", Locale.UK);
+ Calendar cal = GregorianCalendar.getInstance(TimeZone.getTimeZone("GMT"),
+ Locale.UK);
+ fmt.setCalendar(cal);
+ try
+ {
+ Date date = fmt.parse("29MAY97");
+ cal.setTime(date);
+ }
+ catch (Exception e) {
+ System.out.print("");
+ }
+ cal.set(Calendar.HOUR_OF_DAY, 13);
+ logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));
+ cal.add(Calendar.HOUR_OF_DAY, 6);
+ logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));
+ if (cal.get(Calendar.HOUR_OF_DAY) != 19)
+ errln("Fail: Want 19 Got " + cal.get(Calendar.HOUR_OF_DAY));
+ }
+
+ public void Test4070502() {
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1998, 0, 30);
+ Date d = getAssociatedDate(tempcal.getTime());
+ Calendar cal = new GregorianCalendar();
+ cal.setTime(d);
+ if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY ||
+ cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)
+ errln("Fail: Want weekday Got " + d);
+ }
+
+ /**
+ * Get the associated date starting from a specified date NOTE: the
+ * unnecessary "getTime()'s" below are a work-around for a bug in jdk 1.1.3
+ * (and probably earlier versions also)
+ * <p>
+ *
+ * @param d
+ * The date to start from
+ */
+ public static Date getAssociatedDate(Date d) {
+ GregorianCalendar cal = new GregorianCalendar();
+ cal.setTime(d);
+ //cal.add(field, amount); //<-- PROBLEM SEEN WITH field = DATE,MONTH
+ // cal.getTime(); // <--- REMOVE THIS TO SEE BUG
+ while (true) {
+ int wd = cal.get(Calendar.DAY_OF_WEEK);
+ if (wd == Calendar.SATURDAY || wd == Calendar.SUNDAY) {
+ cal.add(Calendar.DATE, 1);
+ // cal.getTime();
+ }
+ else
+ break;
+ }
+ return cal.getTime();
+ }
+
+ public void Test4071197() {
+ 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);
+ logln(cal.getTime().toString());
+ if (min != Calendar.SUNDAY || max != Calendar.SATURDAY)
+ errln("FAIL: Min/max bad");
+ if (dow < min || dow > max)
+ errln("FAIL: Day of week " + dow + " out of range");
+ if (dow != Calendar.SUNDAY)
+ errln("FAIL: Day of week should be SUNDAY Got " + dow);
+ }
+
+ public void Test4071385() {
+ // work around bug for jdk1.4 on solaris 2.6, which uses funky timezone
+ // names
+ // jdk1.4.1 will drop support for 2.6 so we should be ok when it comes out
+ java.util.TimeZone javazone = java.util.TimeZone.getTimeZone("GMT");
+ TimeZone icuzone = TimeZone.getTimeZone("GMT");
+
+ Calendar cal = Calendar.getInstance(icuzone);
+ java.util.Calendar tempcal = java.util.Calendar.getInstance(javazone);
+ tempcal.clear();
+ tempcal.set(1998, Calendar.JUNE, 24);
+ cal.setTime(tempcal.getTime());
+ cal.set(Calendar.MONTH, Calendar.NOVEMBER); // change a field
+ logln(cal.getTime().toString());
+ tempcal.set(1998, Calendar.NOVEMBER, 24);
+ if (!cal.getTime().equals(tempcal.getTime()))
+ errln("Fail");
+ }
+
+ public void Test4073929() {
+ GregorianCalendar foo1 = new GregorianCalendar(1997, 8, 27);
+ foo1.add(Calendar.DAY_OF_MONTH, +1);
+ int testyear = foo1.get(Calendar.YEAR);
+ int testmonth = foo1.get(Calendar.MONTH);
+ int testday = foo1.get(Calendar.DAY_OF_MONTH);
+ if (testyear != 1997 ||
+ testmonth != 8 ||
+ testday != 28)
+ errln("Fail: Calendar not initialized");
+ }
+
+ public void Test4083167() {
+ TimeZone saveZone = TimeZone.getDefault();
+ try {
+ TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+ Date firstDate = new Date();
+ Calendar cal = new GregorianCalendar();
+ cal.setTime(firstDate);
+ long firstMillisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +
+ cal.get(Calendar.MINUTE) * 60000L +
+ cal.get(Calendar.SECOND) * 1000L +
+ cal.get(Calendar.MILLISECOND);
+
+ logln("Current time: " + firstDate.toString());
+
+ for (int validity=0; validity<30; validity++) {
+ Date lastDate = new Date(firstDate.getTime() +
+ (long)validity*1000*24*60*60);
+ cal.setTime(lastDate);
+ long millisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +
+ cal.get(Calendar.MINUTE) * 60000L +
+ cal.get(Calendar.SECOND) * 1000L +
+ cal.get(Calendar.MILLISECOND);
+ if (firstMillisInDay != millisInDay)
+ errln("Day has shifted " + lastDate);
+ }
+ }
+ finally {
+ TimeZone.setDefault(saveZone);
+ }
+ }
+
+ public void Test4086724() {
+ SimpleDateFormat date;
+ TimeZone saveZone = TimeZone.getDefault();
+ Locale saveLocale = Locale.getDefault();
+ try {
+ Locale.setDefault(Locale.UK);
+ TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+ date=new SimpleDateFormat("dd MMM yyy (zzzz) 'is in week' ww");
+ Calendar cal=Calendar.getInstance();
+ cal.set(1997,Calendar.SEPTEMBER,30);
+ Date now=cal.getTime();
+ logln(date.format(now));
+ cal.set(1997,Calendar.JANUARY,1);
+ now=cal.getTime();
+ logln(date.format(now));
+ cal.set(1997,Calendar.JANUARY,8);
+ now=cal.getTime();
+ logln(date.format(now));
+ cal.set(1996,Calendar.DECEMBER,31);
+ now=cal.getTime();
+ logln(date.format(now));
+ }
+ finally {
+ Locale.setDefault(saveLocale);
+ TimeZone.setDefault(saveZone);
+ }
+ logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");
+ }
+
+ public void Test4092362() {
+ GregorianCalendar cal1 = new GregorianCalendar(1997, 10, 11, 10, 20, 40);
+ /*
+ * cal1.set( Calendar.YEAR, 1997 ); cal1.set( Calendar.MONTH, 10 );
+ * cal1.set( Calendar.DATE, 11 ); cal1.set( Calendar.HOUR, 10 );
+ * cal1.set( Calendar.MINUTE, 20 ); cal1.set( Calendar.SECOND, 40 );
+ */
+
+ logln( " Cal1 = " + cal1.getTime().getTime() );
+ logln( " Cal1 time in ms = " + cal1.get(Calendar.MILLISECOND) );
+ for( int k = 0; k < 100 ; k++ ) {
+ System.out.print("");
+ }
+
+ GregorianCalendar cal2 = new GregorianCalendar(1997, 10, 11, 10, 20, 40);
+ /*
+ * cal2.set( Calendar.YEAR, 1997 ); cal2.set( Calendar.MONTH, 10 );
+ * cal2.set( Calendar.DATE, 11 ); cal2.set( Calendar.HOUR, 10 );
+ * cal2.set( Calendar.MINUTE, 20 ); cal2.set( Calendar.SECOND, 40 );
+ */
+
+ logln( " Cal2 = " + cal2.getTime().getTime() );
+ logln( " Cal2 time in ms = " + cal2.get(Calendar.MILLISECOND) );
+ if( !cal1.equals( cal2 ) )
+ errln("Fail: Milliseconds randomized");
+ }
+
+ public void Test4095407() {
+ GregorianCalendar a = new GregorianCalendar(1997,Calendar.NOVEMBER, 13);
+ int dow = a.get(Calendar.DAY_OF_WEEK);
+ if (dow != Calendar.THURSDAY)
+ errln("Fail: Want THURSDAY Got " + dow);
+ }
+
+ public void Test4096231() {
+ TimeZone GMT = TimeZone.getTimeZone("GMT");
+ TimeZone PST = TimeZone.getTimeZone("PST");
+ int sec = 0, min = 0, hr = 0, day = 1, month = 10, year = 1997;
+
+ Calendar cal1 = new GregorianCalendar(PST);
+ cal1.setTime(new Date(880698639000L));
+ int p;
+ logln("PST 1 is: " + (p=cal1.get(Calendar.HOUR_OF_DAY)));
+ cal1.setTimeZone(GMT);
+ // Issue 1: Changing the timezone doesn't change the
+ // represented time.
+ int h1,h2;
+ logln("GMT 1 is: " + (h1=cal1.get(Calendar.HOUR_OF_DAY)));
+ cal1.setTime(new Date(880698639000L));
+ logln("GMT 2 is: " + (h2=cal1.get(Calendar.HOUR_OF_DAY)));
+ // Note: This test had a bug in it. It wanted h1!=h2, when
+ // what was meant was h1!=p. Fixed this concurrent with fix
+ // to 4177484.
+ if (p == h1 || h1 != h2)
+ errln("Fail: Hour same in different zones");
+
+ Calendar cal2 = new GregorianCalendar(GMT);
+ Calendar cal3 = new GregorianCalendar(PST);
+ cal2.set(Calendar.MILLISECOND, 0);
+ cal3.set(Calendar.MILLISECOND, 0);
+
+ cal2.set(cal1.get(Calendar.YEAR),
+ cal1.get(Calendar.MONTH),
+ cal1.get(Calendar.DAY_OF_MONTH),
+ cal1.get(Calendar.HOUR_OF_DAY),
+ cal1.get(Calendar.MINUTE),
+ cal1.get(Calendar.SECOND));
+
+ long t1,t2,t3,t4;
+ logln("RGMT 1 is: " + (t1=cal2.getTime().getTime()));
+ cal3.set(year, month, day, hr, min, sec);
+ logln("RPST 1 is: " + (t2=cal3.getTime().getTime()));
+ cal3.setTimeZone(GMT);
+ logln("RGMT 2 is: " + (t3=cal3.getTime().getTime()));
+ cal3.set(cal1.get(Calendar.YEAR),
+ cal1.get(Calendar.MONTH),
+ cal1.get(Calendar.DAY_OF_MONTH),
+ cal1.get(Calendar.HOUR_OF_DAY),
+ cal1.get(Calendar.MINUTE),
+ cal1.get(Calendar.SECOND));
+ // Issue 2: Calendar continues to use the timezone in its
+ // constructor for set() conversions, regardless
+ // of calls to setTimeZone()
+ logln("RGMT 3 is: " + (t4=cal3.getTime().getTime()));
+ if (t1 == t2 ||
+ t1 != t4 ||
+ t2 != t3)
+ errln("Fail: Calendar zone behavior faulty");
+ }
+
+ public void Test4096539() {
+ int[] y = {31,28,31,30,31,30,31,31,30,31,30,31};
+
+ for (int x=0;x<12;x++) {
+ GregorianCalendar gc = new
+ GregorianCalendar(1997,x,y[x]);
+ int m1,m2;
+ log((m1=gc.get(Calendar.MONTH)+1)+"/"+
+ gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)+
+ " + 1mo = ");
+
+ gc.add(Calendar.MONTH, 1);
+ logln((m2=gc.get(Calendar.MONTH)+1)+"/"+
+ gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)
+ );
+ int m = (m1 % 12) + 1;
+ if (m2 != m)
+ errln("Fail: Want " + m + " Got " + m2);
+ }
+
+ }
+
+ public void Test4100311() {
+ GregorianCalendar cal = (GregorianCalendar)Calendar.getInstance();
+ cal.set(Calendar.YEAR, 1997);
+ cal.set(Calendar.DAY_OF_YEAR, 1);
+ Date d = cal.getTime(); // Should be Jan 1
+ logln(d.toString());
+ if (cal.get(Calendar.DAY_OF_YEAR) != 1)
+ errln("Fail: DAY_OF_YEAR not set");
+ }
+
+ public void Test4103271() {
+ SimpleDateFormat sdf = new SimpleDateFormat();
+ int numYears=40, startYear=1997, numDays=15;
+ String output, testDesc;
+ GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance();
+ testCal.clear();
+ sdf.setCalendar(testCal);
+ sdf.applyPattern("d MMM yyyy");
+ boolean fail = false;
+ for (int firstDay=1; firstDay<=2; firstDay++) {
+ for (int minDays=1; minDays<=7; minDays++) {
+ testCal.setMinimalDaysInFirstWeek(minDays);
+ testCal.setFirstDayOfWeek(firstDay);
+ testDesc = ("Test" + String.valueOf(firstDay) + String.valueOf(minDays));
+ logln(testDesc + " => 1st day of week=" +
+ String.valueOf(firstDay) +
+ ", minimum days in first week=" +
+ String.valueOf(minDays));
+ for (int j=startYear; j<=startYear+numYears; j++) {
+ testCal.set(j,11,25);
+ for(int i=0; i<numDays; i++) {
+ testCal.add(Calendar.DATE,1);
+ String calWOY;
+ int actWOY = testCal.get(Calendar.WEEK_OF_YEAR);
+ if (actWOY < 1 || actWOY > 53) {
+ Date d = testCal.getTime();
+ calWOY = String.valueOf(actWOY);
+ output = testDesc + " - " + sdf.format(d) + "\t";
+ output = output + "\t" + calWOY;
+ logln(output);
+ fail = true;
+ }
+ }
+ }
+ }
+ }
+
+ int[] DATA = {
+ 3, 52, 52, 52, 52, 52, 52, 52,
+ 1, 1, 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 2, 2, 2,
+ 4, 52, 52, 52, 52, 52, 52, 52,
+ 53, 53, 53, 53, 53, 53, 53,
+ 1, 1, 1, 1, 1, 1, 1,
+ };
+ testCal.setFirstDayOfWeek(Calendar.SUNDAY);
+ for (int j=0; j<DATA.length; j+=22) {
+ logln("Minimal days in first week = " + DATA[j] +
+ " Week starts on Sunday");
+ testCal.setMinimalDaysInFirstWeek(DATA[j]);
+ testCal.set(1997, Calendar.DECEMBER, 21);
+ for (int i=0; i<21; ++i) {
+ int woy = testCal.get(Calendar.WEEK_OF_YEAR);
+ log(testCal.getTime() + " " + woy);
+ if (woy != DATA[j + 1 + i]) {
+ log(" ERROR");
+ fail = true;
+ }
+ //logln();
+
+ // Now compute the time from the fields, and make sure we
+ // get the same answer back. This is a round-trip test.
+ Date save = testCal.getTime();
+ testCal.clear();
+ testCal.set(Calendar.YEAR, DATA[j+1+i] < 25 ? 1998 : 1997);
+ testCal.set(Calendar.WEEK_OF_YEAR, DATA[j+1+i]);
+ testCal.set(Calendar.DAY_OF_WEEK, (i%7) + Calendar.SUNDAY);
+ if (!testCal.getTime().equals(save)) {
+ logln(" Parse failed: " + testCal.getTime());
+ fail= true;
+ }
+
+ testCal.setTime(save);
+ testCal.add(Calendar.DAY_OF_MONTH, 1);
+ }
+ }
+
+ Date d[] = new Date[8];
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1997, Calendar.DECEMBER, 28);
+ d[0] = tempcal.getTime();
+ tempcal.set(1998, Calendar.JANUARY, 10);
+ d[1] = tempcal.getTime();
+ tempcal.set(1998, Calendar.DECEMBER, 31);
+ d[2] = tempcal.getTime();
+ tempcal.set(1999, Calendar.JANUARY, 1);
+ d[3] = tempcal.getTime();
+ // Test field disambiguation with a few special hard-coded cases.
+ // This shouldn't fail if the above cases aren't failing.
+ Object[] DISAM = {
+ new Integer(1998), new Integer(1), new Integer(Calendar.SUNDAY),
+ d[0],
+ new Integer(1998), new Integer(2), new Integer(Calendar.SATURDAY),
+ d[1],
+ new Integer(1998), new Integer(53), new Integer(Calendar.THURSDAY),
+ d[2],
+ new Integer(1998), new Integer(53), new Integer(Calendar.FRIDAY),
+ d[3],
+ };
+ testCal.setMinimalDaysInFirstWeek(3);
+ testCal.setFirstDayOfWeek(Calendar.SUNDAY);
+ for (int i=0; i<DISAM.length; i+=4) {
+ int y = ((Integer)DISAM[i]).intValue();
+ int woy = ((Integer)DISAM[i+1]).intValue();
+ int dow = ((Integer)DISAM[i+2]).intValue();
+ Date exp = (Date)DISAM[i+3];
+ testCal.clear();
+ testCal.set(Calendar.YEAR, y);
+ testCal.set(Calendar.WEEK_OF_YEAR, woy);
+ testCal.set(Calendar.DAY_OF_WEEK, dow);
+ log(y + "-W" + woy +
+ "-DOW" + dow + " expect:" + exp +
+ " got:" + testCal.getTime());
+ if (!testCal.getTime().equals(exp)) {
+ log(" FAIL");
+ fail = true;
+ }
+ //logln();
+ }
+
+ // Now try adding and rolling
+ Object ADD = new Object();
+ Object ROLL = new Object();
+ tempcal.set(1998, Calendar.DECEMBER, 25);
+ d[0] = tempcal.getTime();
+ tempcal.set(1999, Calendar.JANUARY, 1);
+ d[1] = tempcal.getTime();
+ tempcal.set(1997, Calendar.DECEMBER, 28);
+ d[2] = tempcal.getTime();
+ tempcal.set(1998, Calendar.JANUARY, 4);
+ d[3] = tempcal.getTime();
+ tempcal.set(1998, Calendar.DECEMBER, 27);
+ d[4] = tempcal.getTime();
+ tempcal.set(1997, Calendar.DECEMBER, 28);
+ d[5] = tempcal.getTime();
+ tempcal.set(1999, Calendar.JANUARY, 2);
+ d[6] = tempcal.getTime();
+ tempcal.set(1998, Calendar.JANUARY, 3);
+ d[7] = tempcal.getTime();
+
+ Object[] ADDROLL = {
+ ADD, new Integer(1), d[0], d[1],
+ ADD, new Integer(1), d[2], d[3],
+ ROLL, new Integer(1), d[4], d[5],
+ ROLL, new Integer(1), d[6], d[7],
+ };
+ testCal.setMinimalDaysInFirstWeek(3);
+ testCal.setFirstDayOfWeek(Calendar.SUNDAY);
+ for (int i=0; i<ADDROLL.length; i+=4) {
+ int amount = ((Integer)ADDROLL[i+1]).intValue();
+ Date before = (Date)ADDROLL[i+2];
+ Date after = (Date)ADDROLL[i+3];
+
+ testCal.setTime(before);
+ if (ADDROLL[i] == ADD) testCal.add(Calendar.WEEK_OF_YEAR, amount);
+ else testCal.roll(Calendar.WEEK_OF_YEAR, amount);
+ log((ADDROLL[i]==ADD?"add(WOY,":"roll(WOY,") +
+ amount + ") " + before + " => " +
+ testCal.getTime());
+ if (!after.equals(testCal.getTime())) {
+ logln(" exp:" + after + " FAIL");
+ fail = true;
+ }
+ else logln(" ok");
+
+ testCal.setTime(after);
+ if (ADDROLL[i] == ADD) testCal.add(Calendar.WEEK_OF_YEAR, -amount);
+ else testCal.roll(Calendar.WEEK_OF_YEAR, -amount);
+ log((ADDROLL[i]==ADD?"add(WOY,":"roll(WOY,") +
+ (-amount) + ") " + after + " => " +
+ testCal.getTime());
+ if (!before.equals(testCal.getTime())) {
+ logln(" exp:" + before + " FAIL");
+ fail = true;
+ }
+ else logln(" ok");
+ }
+
+ if (fail) errln("Fail: Week of year misbehaving");
+ }
+
+ public void Test4106136() {
+ Locale saveLocale = Locale.getDefault();
+ String[] names = { "Calendar", "DateFormat", "NumberFormat" };
+ try {
+ Locale[] locales = { Locale.CHINESE, Locale.CHINA };
+ for (int i=0; i<locales.length; ++i) {
+ Locale.setDefault(locales[i]);
+ int[] n = {
+ Calendar.getAvailableLocales().length,
+ DateFormat.getAvailableLocales().length,
+ NumberFormat.getAvailableLocales().length
+ };
+ for (int j=0; j<n.length; ++j) {
+ if (n[j] == 0)
+ errln("Fail: " + names[j] + " has no locales for " + locales[i]);
+ }
+ }
+ }
+ finally {
+ Locale.setDefault(saveLocale);
+ }
+ }
+
+ public void Test4108764() {
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 00, 00);
+ Date d00 = tempcal.getTime();
+ tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 00, 56);
+ Date d01 = tempcal.getTime();
+ tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 34, 00);
+ Date d10 = tempcal.getTime();
+ tempcal.set(1997, Calendar.FEBRUARY, 15, 12, 34, 56);
+ Date d11 = tempcal.getTime();
+ tempcal.set(1997, Calendar.JANUARY, 15, 12, 34, 56);
+ Date dM = tempcal.getTime();
+ tempcal.clear();
+ tempcal.set(1970, Calendar.JANUARY, 1);
+ Date epoch = tempcal.getTime();
+
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(d11);
+
+ cal.clear( Calendar.MINUTE );
+ logln(cal.getTime().toString());
+ if (!cal.getTime().equals(d01)) {
+ errln("Fail: " + d11 + " clear(MINUTE) => expect " +
+ d01 + ", got " + cal.getTime());
+ }
+
+ cal.set( Calendar.SECOND, 0 );
+ logln(cal.getTime().toString());
+ if (!cal.getTime().equals(d00))
+ errln("Fail: set(SECOND, 0) broken");
+
+ cal.setTime(d11);
+ cal.set( Calendar.SECOND, 0 );
+ logln(cal.getTime().toString());
+ if (!cal.getTime().equals(d10))
+ errln("Fail: set(SECOND, 0) broken #2");
+
+ cal.clear( Calendar.MINUTE );
+ logln(cal.getTime().toString());
+ if (!cal.getTime().equals(d00))
+ errln("Fail: clear(MINUTE) broken #2");
+
+ cal.clear();
+ logln(cal.getTime().toString());
+ if (!cal.getTime().equals(epoch))
+ errln("Fail: after clear() expect " + epoch + ", got " + cal.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. March 15
+//## // was not in DST before, but with the new rule, it is
+//## // in DST.
+//#else
+ cal.setTime(d11);
+ cal.clear( Calendar.MONTH );
+ logln(cal.getTime().toString());
+ if (!cal.getTime().equals(dM)) {
+ errln("Fail: " + d11 + " clear(MONTH) => expect " +
+ dM + ", got " + cal.getTime());
+ }
+//#endif
+ }
+
+ public void Test4114578() {
+ int ONE_HOUR = 60*60*1000;
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeZone(TimeZone.getTimeZone("PST"));
+
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1998, Calendar.APRIL, 5, 1, 0);
+ long onset = tempcal.getTime().getTime() + ONE_HOUR;
+ tempcal.set(1998, Calendar.OCTOBER, 25, 0, 0);
+ long cease = tempcal.getTime().getTime() + 2*ONE_HOUR;
+
+ boolean fail = false;
+
+ final int ADD = 1;
+ final int ROLL = 2;
+
+ long[] DATA = {
+ // Start Action Amt Expected_change
+ onset - ONE_HOUR, ADD, 1, ONE_HOUR,
+ onset, ADD, -1, -ONE_HOUR,
+ onset - ONE_HOUR, ROLL, 1, ONE_HOUR,
+ onset, ROLL, -1, -ONE_HOUR,
+ cease - ONE_HOUR, ADD, 1, ONE_HOUR,
+ cease, ADD, -1, -ONE_HOUR,
+ cease - ONE_HOUR, ROLL, 1, ONE_HOUR,
+ cease, ROLL, -1, -ONE_HOUR,
+ };
+
+ for (int i=0; i<DATA.length; i+=4) {
+ Date date = new Date(DATA[i]);
+ int amt = (int) DATA[i+2];
+ long expectedChange = DATA[i+3];
+
+ log(date.toString());
+ cal.setTime(date);
+
+ switch ((int) DATA[i+1]) {
+ case ADD:
+ log(" add (HOUR," + (amt<0?"":"+")+amt + ")= ");
+ cal.add(Calendar.HOUR, amt);
+ break;
+ case ROLL:
+ log(" roll(HOUR," + (amt<0?"":"+")+amt + ")= ");
+ cal.roll(Calendar.HOUR, amt);
+ break;
+ }
+
+ log(cal.getTime().toString());
+
+ long change = cal.getTime().getTime() - date.getTime();
+ if (change != expectedChange) {
+ fail = true;
+ logln(" FAIL");
+ }
+ else logln(" OK");
+ }
+
+ if (fail) errln("Fail: roll/add misbehaves around DST onset/cease");
+ }
+
+ /**
+ * Make sure maximum for HOUR field is 11, not 12.
+ */
+ public void Test4118384() {
+ Calendar cal = Calendar.getInstance();
+ if (cal.getMaximum(Calendar.HOUR) != 11 ||
+ cal.getLeastMaximum(Calendar.HOUR) != 11 ||
+ cal.getActualMaximum(Calendar.HOUR) != 11)
+ errln("Fail: maximum of HOUR field should be 11");
+ }
+
+ /**
+ * Check isLeapYear for BC years.
+ */
+ public void Test4125881() {
+ GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
+ DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");
+ cal.clear();
+ for (int y=-20; y<=10; ++y) {
+ cal.set(Calendar.ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);
+ cal.set(Calendar.YEAR, y < 1 ? 1 - y : y);
+ logln(y + " = " + fmt.format(cal.getTime()) + " " +
+ cal.isLeapYear(y));
+ if (cal.isLeapYear(y) != ((y+40)%4 == 0))
+ errln("Leap years broken");
+ }
+ }
+
+ // I am disabling this test -- it is currently failing because of a bug
+ // in Sun's latest change to STZ.getOffset(). I have filed a Sun bug
+ // against this problem.
+
+ // Re-enabled after 'porting' TZ and STZ from java.util to com.ibm.icu.util.
+ /**
+ * Prove that GregorianCalendar is proleptic (it used to cut off at 45 BC,
+ * and not have leap years before then).
+ */
+ public void Test4125892() {
+ GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
+ //DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");
+ //fmt = null;
+ cal.clear();
+ cal.set(Calendar.ERA, GregorianCalendar.BC);
+ cal.set(Calendar.YEAR, 81); // 81 BC is a leap year (proleptically)
+ cal.set(Calendar.MONTH, Calendar.FEBRUARY);
+ cal.set(Calendar.DATE, 28);
+ cal.add(Calendar.DATE, 1);
+ if (cal.get(Calendar.DATE) != 29 ||
+ !cal.isLeapYear(-80)) // -80 == 81 BC
+ errln("Calendar not proleptic");
+ }
+
+ /**
+ * Calendar and GregorianCalendar hashCode() methods need improvement.
+ * Calendar needs a good implementation that subclasses can override, and
+ * GregorianCalendar should use that implementation.
+ */
+ public void Test4136399() {
+ /*
+ * Note: This test is actually more strict than it has to be.
+ * Technically, there is no requirement that unequal objects have
+ * unequal hashes. We only require equal objects to have equal hashes.
+ * It is desirable for unequal objects to have distributed hashes, but
+ * there is no hard requirement here.
+ *
+ * In this test we make assumptions about certain attributes of calendar
+ * objects getting represented in the hash, which need not always be the
+ * case (although it does work currently with the given test).
+ */
+ Calendar a = Calendar.getInstance();
+ Calendar b = (Calendar)a.clone();
+ if (a.hashCode() != b.hashCode()) {
+ errln("Calendar hash code unequal for cloned objects");
+ }
+ TimeZone atz1 = a.getTimeZone();
+ TimeZone atz2 = (TimeZone)atz1.clone();
+ if(!atz1.equals(atz2)){
+ errln("The clone timezones are not equal");
+ }
+ if(atz1.hashCode()!=atz2.hashCode()){
+ errln("TimeZone hash code unequal for cloned objects");
+ }
+ b.setMinimalDaysInFirstWeek(7 - a.getMinimalDaysInFirstWeek());
+ if (a.hashCode() == b.hashCode()) {
+ errln("Calendar hash code ignores minimal days in first week");
+ }
+ b.setMinimalDaysInFirstWeek(a.getMinimalDaysInFirstWeek());
+
+ b.setFirstDayOfWeek((a.getFirstDayOfWeek() % 7) + 1); // Next day
+ if (a.hashCode() == b.hashCode()) {
+ errln("Calendar hash code ignores first day of week");
+ }
+ b.setFirstDayOfWeek(a.getFirstDayOfWeek());
+
+ b.setLenient(!a.isLenient());
+ if (a.hashCode() == b.hashCode()) {
+ errln("Calendar hash code ignores lenient setting");
+ }
+ b.setLenient(a.isLenient());
+
+ // Assume getTimeZone() returns a reference, not a clone
+ // of a reference -- this is true as of this writing
+ TimeZone atz = a.getTimeZone();
+ TimeZone btz = b.getTimeZone();
+
+ btz.setRawOffset(atz.getRawOffset() + 60*60*1000);
+ if(atz.hashCode()== btz.hashCode()){
+ errln(atz.hashCode()+"=="+btz.hashCode());
+ }
+ if (a.getTimeZone()!= b.getTimeZone() && a.hashCode() == b.hashCode()) {
+ errln("Calendar hash code ignores zone");
+ }
+ b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset());
+
+ GregorianCalendar c = new GregorianCalendar();
+ GregorianCalendar d = (GregorianCalendar)c.clone();
+ if (c.hashCode() != d.hashCode()) {
+ errln("GregorianCalendar hash code unequal for clones objects");
+ }
+ Date cutover = c.getGregorianChange();
+ d.setGregorianChange(new Date(cutover.getTime() + 24*60*60*1000));
+ if (c.hashCode() == d.hashCode()) {
+ errln("GregorianCalendar hash code ignores cutover");
+ }
+ }
+
+ /**
+ * GregorianCalendar.equals() ignores cutover date
+ */
+ public void Test4141665() {
+ GregorianCalendar cal = new GregorianCalendar();
+ GregorianCalendar cal2 = (GregorianCalendar)cal.clone();
+ Date cut = cal.getGregorianChange();
+ Date cut2 = new Date(cut.getTime() + 100*24*60*60*1000L); // 100 days
+ // later
+ if (!cal.equals(cal2)) {
+ errln("Cloned GregorianCalendars not equal");
+ }
+ cal2.setGregorianChange(cut2);
+ if (cal.equals(cal2)) {
+ errln("GregorianCalendar.equals() ignores cutover");
+ }
+ }
+
+ /**
+ * Bug states that ArrayIndexOutOfBoundsException is thrown by
+ * GregorianCalendar.roll() when IllegalArgumentException should be.
+ */
+ public void Test4142933() {
+ GregorianCalendar calendar = new GregorianCalendar();
+ try {
+ calendar.roll(-1, true);
+ errln("Test failed, no exception trown");
+ }
+ catch (IllegalArgumentException e) {
+ // OK: Do nothing
+ // logln("Test passed");
+ System.out.print("");
+ }
+ catch (Exception e) {
+ errln("Test failed. Unexpected exception is thrown: " + e);
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is
+ * confusing; unless the time zone has a raw offset of zero, one or the
+ * other of these will wrap. We've modified the test given in the bug report
+ * to therefore only check the behavior of a calendar with a zero raw offset
+ * zone.
+ */
+ public void Test4145158() {
+ GregorianCalendar calendar = new GregorianCalendar();
+
+ calendar.setTimeZone(TimeZone.getTimeZone("GMT"));
+
+ calendar.setTime(new Date(Long.MIN_VALUE));
+ int year1 = calendar.get(Calendar.YEAR);
+ int era1 = calendar.get(Calendar.ERA);
+
+ calendar.setTime(new Date(Long.MAX_VALUE));
+ int year2 = calendar.get(Calendar.YEAR);
+ int era2 = calendar.get(Calendar.ERA);
+
+ if (year1 == year2 && era1 == era2) {
+ errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");
+ }
+ }
+
+ /**
+ * Maximum value for YEAR field wrong.
+ */
+ public void Test4145983() {
+ GregorianCalendar calendar = new GregorianCalendar();
+ calendar.setTimeZone(TimeZone.getTimeZone("GMT"));
+ Date[] DATES = { new Date(Long.MAX_VALUE), new Date(Long.MIN_VALUE) };
+ for (int i=0; i<DATES.length; ++i) {
+ calendar.setTime(DATES[i]);
+ int year = calendar.get(Calendar.YEAR);
+ int maxYear = calendar.getMaximum(Calendar.YEAR);
+ if (year > maxYear) {
+ errln("Failed for "+DATES[i].getTime()+" ms: year=" +
+ year + ", maxYear=" + maxYear);
+ }
+ }
+ }
+
+ /**
+ * This is a bug in the validation code of GregorianCalendar. As reported,
+ * the bug seems worse than it really is, due to a bug in the way the bug
+ * report test was written. In reality the bug is restricted to the
+ * DAY_OF_YEAR field. - liu 6/29/98
+ */
+ public void Test4147269() {
+ GregorianCalendar calendar = new GregorianCalendar();
+ calendar.setLenient(false);
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(1996, Calendar.JANUARY, 3); // Arbitrary date
+ Date date = tempcal.getTime();
+ for (int field = 0; field < calendar.getFieldCount(); field++) {
+ calendar.setTime(date);
+ // Note: In the bug report, getActualMaximum() was called instead
+ // of getMaximum() -- this was an error. The validation code doesn't
+ // use getActualMaximum(), since that's too costly.
+ int max = calendar.getMaximum(field);
+ int value = max+1;
+ calendar.set(field, value);
+ try {
+ calendar.getTime(); // Force time computation
+ // We expect an exception to be thrown. If we fall through
+ // to the next line, then we have a bug.
+ errln("Test failed with field " + FIELD_NAME[field] +
+ ", date before: " + date +
+ ", date after: " + calendar.getTime() +
+ ", value: " + value + " (max = " + max +")");
+ } catch (IllegalArgumentException e) {
+ System.out.print("");
+ }
+ }
+ }
+
+ /**
+ * Reported bug is that a GregorianCalendar with a cutover of
+ * Date(Long.MAX_VALUE) doesn't behave as a pure Julian calendar. CANNOT
+ * REPRODUCE THIS BUG
+ */
+ public void Test4149677() {
+ TimeZone[] zones = { TimeZone.getTimeZone("GMT"),
+ TimeZone.getTimeZone("PST"),
+ TimeZone.getTimeZone("EAT") };
+ for (int i=0; i<zones.length; ++i) {
+ GregorianCalendar calendar = new GregorianCalendar(zones[i]);
+
+ // Make sure extreme values don't wrap around
+ calendar.setTime(new Date(Long.MIN_VALUE));
+ if (calendar.get(Calendar.ERA) != GregorianCalendar.BC) {
+ errln("Fail: Long.MIN_VALUE ms has an AD year");
+ }
+ calendar.setTime(new Date(Long.MAX_VALUE));
+ if (calendar.get(Calendar.ERA) != GregorianCalendar.AD) {
+ errln("Fail: Long.MAX_VALUE ms has a BC year");
+ }
+
+ calendar.setGregorianChange(new Date(Long.MAX_VALUE));
+ // to obtain a pure Julian calendar
+
+ boolean is100Leap = calendar.isLeapYear(100);
+ if (!is100Leap) {
+ errln("test failed with zone " + zones[i].getID());
+ errln(" cutover date is Calendar.MAX_DATE");
+ errln(" isLeapYear(100) returns: " + is100Leap);
+ }
+ }
+ }
+
+ /**
+ * Calendar and Date HOUR broken. If HOUR is out-of-range, Calendar and Date
+ * classes will misbehave.
+ */
+ public void Test4162587() {
+ TimeZone tz = TimeZone.getTimeZone("PST");
+ TimeZone.setDefault(tz);
+ GregorianCalendar cal = new GregorianCalendar(tz);
+ Date d;
+
+ for (int i=0; i<5; ++i) {
+ if (i>0) logln("---");
+
+ cal.clear();
+ cal.set(1998, Calendar.APRIL, 5, i, 0);
+ d = cal.getTime();
+ String s0 = d.toString();
+ logln("0 " + i + ": " + s0);
+
+ cal.clear();
+ cal.set(1998, Calendar.APRIL, 4, i+24, 0);
+ d = cal.getTime();
+ String sPlus = d.toString();
+ logln("+ " + i + ": " + sPlus);
+
+ cal.clear();
+ cal.set(1998, Calendar.APRIL, 6, i-24, 0);
+ d = cal.getTime();
+ String sMinus = d.toString();
+ logln("- " + i + ": " + sMinus);
+
+ if (!s0.equals(sPlus) || !s0.equals(sMinus)) {
+ errln("Fail: All three lines must match");
+ }
+ }
+ }
+
+ /**
+ * Adding 12 months behaves differently from adding 1 year
+ */
+ public void Test4165343() {
+ GregorianCalendar calendar = new GregorianCalendar(1996, Calendar.FEBRUARY, 29);
+ Date start = calendar.getTime();
+ logln("init date: " + start);
+ calendar.add(Calendar.MONTH, 12);
+ Date date1 = calendar.getTime();
+ logln("after adding 12 months: " + date1);
+ calendar.setTime(start);
+ calendar.add(Calendar.YEAR, 1);
+ Date date2 = calendar.getTime();
+ logln("after adding one year : " + date2);
+ if (date1.equals(date2)) {
+ logln("Test passed");
+ } else {
+ errln("Test failed");
+ }
+ }
+
+ /**
+ * GregorianCalendar.getActualMaximum() does not account for first day of
+ * week.
+ */
+ public void Test4166109() {
+ /*
+ * Test month:
+ *
+ * March 1998 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+ * 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+ */
+ boolean passed = true;
+ int field = Calendar.WEEK_OF_MONTH;
+
+ GregorianCalendar calendar = new GregorianCalendar(Locale.US);
+ calendar.set(1998, Calendar.MARCH, 1);
+ calendar.setMinimalDaysInFirstWeek(1);
+ logln("Date: " + calendar.getTime());
+
+ int firstInMonth = calendar.get(Calendar.DAY_OF_MONTH);
+
+ for (int firstInWeek = Calendar.SUNDAY; firstInWeek <= Calendar.SATURDAY; firstInWeek++) {
+ calendar.setFirstDayOfWeek(firstInWeek);
+ int returned = calendar.getActualMaximum(field);
+ int expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7;
+
+ logln("First day of week = " + firstInWeek +
+ " getActualMaximum(WEEK_OF_MONTH) = " + returned +
+ " expected = " + expected +
+ ((returned == expected) ? " ok" : " FAIL"));
+
+ if (returned != expected) {
+ passed = false;
+ }
+ }
+ if (!passed) {
+ errln("Test failed");
+ }
+ }
+
+ /**
+ * Calendar.getActualMaximum(YEAR) works wrong.
+ */
+ public void Test4167060() {
+ int field = Calendar.YEAR;
+ DateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy G",
+ Locale.US);
+
+ GregorianCalendar calendars[] = {
+ new GregorianCalendar(100, Calendar.NOVEMBER, 1),
+ new GregorianCalendar(-99 /* 100BC */, Calendar.JANUARY, 1),
+ new GregorianCalendar(1996, Calendar.FEBRUARY, 29),
+ };
+
+ String[] id = { "Hybrid", "Gregorian", "Julian" };
+
+ for (int k=0; k<3; ++k) {
+ logln("--- " + id[k] + " ---");
+
+ for (int j=0; j<calendars.length; ++j) {
+ GregorianCalendar calendar = calendars[j];
+ if (k == 1) {
+ calendar.setGregorianChange(new Date(Long.MIN_VALUE));
+ } else if (k == 2) {
+ calendar.setGregorianChange(new Date(Long.MAX_VALUE));
+ }
+
+ format.setCalendar((Calendar)calendar.clone());
+
+ Date dateBefore = calendar.getTime();
+
+ int maxYear = calendar.getActualMaximum(field);
+ logln("maxYear: " + maxYear + " for " + format.format(calendar.getTime()));
+ logln("date before: " + format.format(dateBefore));
+
+ int years[] = {2000, maxYear-1, maxYear, maxYear+1};
+
+ for (int i = 0; i < years.length; i++) {
+ boolean valid = years[i] <= maxYear;
+ calendar.set(field, years[i]);
+ Date dateAfter = calendar.getTime();
+ int newYear = calendar.get(field);
+ calendar.setTime(dateBefore); // restore calendar for next
+ // use
+
+ logln(" Year " + years[i] + (valid? " ok " : " bad") +
+ " => " + format.format(dateAfter));
+ if (valid && newYear != years[i]) {
+ errln(" FAIL: " + newYear + " should be valid; date, month and time shouldn't change");
+ } else if (!valid && newYear == years[i]) {
+ // We no longer require strict year maxima. That is, the
+ // calendar
+ // algorithm may work for values > the stated maximum.
+ //errln(" FAIL: " + newYear + " should be invalid");
+ logln(" Note: " + newYear + " > maximum, but still valid");
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Calendar.roll broken This bug relies on the TimeZone bug 4173604 to also
+ * be fixed.
+ */
+ public void Test4173516() {
+ int fieldsList[][] = {
+ { 1997, Calendar.FEBRUARY, 1, 10, 45, 15, 900 },
+ { 1999, Calendar.DECEMBER, 22, 23, 59, 59, 999 }
+ };
+ int limit = 40;
+ GregorianCalendar cal = new GregorianCalendar();
+
+ cal.setTime(new Date(0));
+ cal.roll(Calendar.HOUR, 0x7F000000);
+ cal.roll(Calendar.HOUR, -0x7F000000);
+ if (cal.getTime().getTime() != 0) {
+ errln("Hour rolling broken");
+ }
+
+ for (int op=0; op<2; ++op) {
+ logln("Testing GregorianCalendar " +
+ (op==0 ? "add" : "roll"));
+ for (int field=0; field < cal.getFieldCount(); ++field) {
+ if (field != Calendar.ZONE_OFFSET &&
+ field != Calendar.DST_OFFSET) {
+ for (int j=0; j<fieldsList.length; ++j) {
+ int fields[] = fieldsList[j];
+ cal.clear();
+ cal.set(fields[0], fields[1], fields[2],
+ fields[3], fields[4], fields[5]);
+ cal.set(Calendar.MILLISECOND, fields[6]);
+ cal.setMinimalDaysInFirstWeek(1);
+ for (int i = 0; i < 2*limit; i++) {
+ if (op == 0) {
+ cal.add(field, i < limit ? 1 : -1);
+ } else {
+ cal.roll(field, i < limit ? 1 : -1);
+ }
+ }
+ if (cal.get(Calendar.YEAR) != fields[0] ||
+ cal.get(Calendar.MONTH) != fields[1] ||
+ cal.get(Calendar.DATE) != fields[2] ||
+ cal.get(Calendar.HOUR_OF_DAY) != fields[3] ||
+ cal.get(Calendar.MINUTE) != fields[4] ||
+ cal.get(Calendar.SECOND) != fields[5] ||
+ cal.get(Calendar.MILLISECOND) != fields[6]) {
+ errln("Field " + field +
+ " (" + FIELD_NAME[field] +
+ ") FAIL, expected " +
+ fields[0] +
+ "/" + (fields[1] + 1) +
+ "/" + fields[2] +
+ " " + fields[3] +
+ ":" + fields[4] +
+ ":" + fields[5] +
+ "." + fields[6] +
+ ", got " + cal.get(Calendar.YEAR) +
+ "/" + (cal.get(Calendar.MONTH) + 1) +
+ "/" + cal.get(Calendar.DATE) +
+ " " + cal.get(Calendar.HOUR_OF_DAY) +
+ ":" + cal.get(Calendar.MINUTE) +
+ ":" + cal.get(Calendar.SECOND) +
+ "." + cal.get(Calendar.MILLISECOND));
+ cal.clear();
+ cal.set(fields[0], fields[1], fields[2],
+ fields[3], fields[4], fields[5]);
+ cal.set(Calendar.MILLISECOND, fields[6]);
+ logln("Start date: " + cal.get(Calendar.YEAR) +
+ "/" + (cal.get(Calendar.MONTH) + 1) +
+ "/" + cal.get(Calendar.DATE) +
+ " " + cal.get(Calendar.HOUR_OF_DAY) +
+ ":" + cal.get(Calendar.MINUTE) +
+ ":" + cal.get(Calendar.SECOND) +
+ "." + cal.get(Calendar.MILLISECOND));
+ long prev = cal.getTime().getTime();
+ for (int i = 0; i < 2*limit; i++) {
+ if (op == 0) {
+ cal.add(field, i < limit ? 1 : -1);
+ } else {
+ cal.roll(field, i < limit ? 1 : -1);
+ }
+ long t = cal.getTime().getTime();
+ long delta = t - prev;
+ prev = t;
+ logln((op == 0 ? "add(" : "roll(") + FIELD_NAME[field] +
+ (i < limit ? ", +1) => " : ", -1) => ") +
+ cal.get(Calendar.YEAR) +
+ "/" + (cal.get(Calendar.MONTH) + 1) +
+ "/" + cal.get(Calendar.DATE) +
+ " " + cal.get(Calendar.HOUR_OF_DAY) +
+ ":" + cal.get(Calendar.MINUTE) +
+ ":" + cal.get(Calendar.SECOND) +
+ "." + cal.get(Calendar.MILLISECOND) +
+ " delta=" + delta + " ms");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public void Test4174361() {
+ GregorianCalendar calendar = new GregorianCalendar(1996, 1, 29);
+
+ calendar.add(Calendar.MONTH, 10);
+ //Date date1 = calendar.getTime();
+ //date1 = null;
+ int d1 = calendar.get(Calendar.DAY_OF_MONTH);
+
+ calendar = new GregorianCalendar(1996, 1, 29);
+ calendar.add(Calendar.MONTH, 11);
+ //Date date2 = calendar.getTime();
+ //date2 = null;
+ int d2 = calendar.get(Calendar.DAY_OF_MONTH);
+
+ if (d1 != d2) {
+ errln("adding months to Feb 29 broken");
+ }
+ }
+
+ /**
+ * Calendar does not update field values when setTimeZone is called.
+ */
+ public void Test4177484() {
+ TimeZone PST = TimeZone.getTimeZone("PST");
+ TimeZone EST = TimeZone.getTimeZone("EST");
+
+ Calendar cal = Calendar.getInstance(PST, Locale.US);
+ cal.clear();
+ cal.set(1999, 3, 21, 15, 5, 0); // Arbitrary
+ int h1 = cal.get(Calendar.HOUR_OF_DAY);
+ cal.setTimeZone(EST);
+ int h2 = cal.get(Calendar.HOUR_OF_DAY);
+ if (h1 == h2) {
+ errln("FAIL: Fields not updated after setTimeZone");
+ }
+
+ // getTime() must NOT change when time zone is changed.
+ // getTime() returns zone-independent time in ms.
+ cal.clear();
+ cal.setTimeZone(PST);
+ cal.set(Calendar.HOUR_OF_DAY, 10);
+ Date pst10 = cal.getTime();
+ cal.setTimeZone(EST);
+ Date est10 = cal.getTime();
+ if (!pst10.equals(est10)) {
+ errln("FAIL: setTimeZone changed time");
+ }
+ }
+
+ /**
+ * Week of year is wrong at the start and end of the year.
+ */
+ public void Test4197699() {
+ GregorianCalendar cal = new GregorianCalendar();
+ cal.setFirstDayOfWeek(Calendar.MONDAY);
+ cal.setMinimalDaysInFirstWeek(4);
+ DateFormat fmt = new SimpleDateFormat("E dd MMM yyyy 'DOY='D 'WOY='w");
+ fmt.setCalendar(cal);
+
+ int[] DATA = {
+ 2000, Calendar.JANUARY, 1, 52,
+ 2001, Calendar.DECEMBER, 31, 1,
+ };
+
+ for (int i=0; i<DATA.length; ) {
+ cal.set(DATA[i++], DATA[i++], DATA[i++]);
+ int expWOY = DATA[i++];
+ int actWOY = cal.get(Calendar.WEEK_OF_YEAR);
+ if (expWOY == actWOY) {
+ logln("Ok: " + fmt.format(cal.getTime()));
+ } else {
+ errln("FAIL: " + fmt.format(cal.getTime())
+ + ", expected WOY=" + expWOY);
+ cal.add(Calendar.DATE, -8);
+ for (int j=0; j<14; ++j) {
+ cal.add(Calendar.DATE, 1);
+ logln(fmt.format(cal.getTime()));
+ }
+ }
+ }
+ }
+
+ /**
+ * Calendar DAY_OF_WEEK_IN_MONTH fields->time broken. The problem is in the
+ * field disambiguation code in GregorianCalendar. This code is supposed to
+ * choose the most recent set of fields among the following:
+ *
+ * MONTH + DAY_OF_MONTH MONTH + WEEK_OF_MONTH + DAY_OF_WEEK MONTH +
+ * DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK DAY_OF_YEAR WEEK_OF_YEAR + DAY_OF_WEEK
+ */
+ public void Test4209071() {
+ Calendar cal = Calendar.getInstance(Locale.US);
+
+ // General field setting test
+ int Y = 1995;
+
+ Date d[] = new Date[13];
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.clear();
+ tempcal.set(Y, Calendar.JANUARY, 1);
+ d[0] = tempcal.getTime();
+ tempcal.set(Y, Calendar.MARCH, 1);
+ d[1] = tempcal.getTime();
+ tempcal.set(Y, Calendar.JANUARY, 4);
+ d[2] = tempcal.getTime();
+ tempcal.set(Y, Calendar.JANUARY, 18);
+ d[3] = tempcal.getTime();
+ tempcal.set(Y, Calendar.JANUARY, 18);
+ d[4] = tempcal.getTime();
+ tempcal.set(Y-1, Calendar.DECEMBER, 22);
+ d[5] = tempcal.getTime();
+ tempcal.set(Y, Calendar.JANUARY, 26);
+ d[6] = tempcal.getTime();
+ tempcal.set(Y, Calendar.JANUARY, 26);
+ d[7] = tempcal.getTime();
+ tempcal.set(Y, Calendar.MARCH, 1);
+ d[8] = tempcal.getTime();
+ tempcal.set(Y, Calendar.OCTOBER, 6);
+ d[9] = tempcal.getTime();
+ tempcal.set(Y, Calendar.OCTOBER, 13);
+ d[10] = tempcal.getTime();
+ tempcal.set(Y, Calendar.AUGUST, 10);
+ d[11] = tempcal.getTime();
+ tempcal.set(Y, Calendar.DECEMBER, 7);
+ d[12] = tempcal.getTime();
+
+ Object[] FIELD_DATA = {
+ // Add new test cases as needed.
+
+ // 0
+ new int[] {}, d[0],
+ // 1
+ new int[] { Calendar.MONTH, Calendar.MARCH }, d[1],
+ // 2
+ new int[] { Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY }, d[2],
+ // 3
+ new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,
+ Calendar.DAY_OF_MONTH, 18, }, d[3],
+ // 4
+ new int[] { Calendar.DAY_OF_MONTH, 18,
+ Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[4],
+ // 5 (WOM -1 is in previous month)
+ new int[] { Calendar.DAY_OF_MONTH, 18,
+ Calendar.WEEK_OF_MONTH, -1,
+ Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[5],
+ // 6
+ new int[] { Calendar.DAY_OF_MONTH, 18,
+ Calendar.WEEK_OF_MONTH, 4,
+ Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[6],
+ // 7 (DIM -1 is in same month)
+ new int[] { Calendar.DAY_OF_MONTH, 18,
+ Calendar.DAY_OF_WEEK_IN_MONTH, -1,
+ Calendar.DAY_OF_WEEK, Calendar.THURSDAY, }, d[7],
+ // 8
+ new int[] { Calendar.WEEK_OF_YEAR, 9,
+ Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY, }, d[8],
+ // 9
+ new int[] { Calendar.MONTH, Calendar.OCTOBER,
+ Calendar.DAY_OF_WEEK_IN_MONTH, 1,
+ Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[9],
+ // 10
+ new int[] { Calendar.MONTH, Calendar.OCTOBER,
+ Calendar.WEEK_OF_MONTH, 2,
+ Calendar.DAY_OF_WEEK, Calendar.FRIDAY, }, d[10],
+ // 11
+ new int[] { Calendar.MONTH, Calendar.OCTOBER,
+ Calendar.DAY_OF_MONTH, 15,
+ Calendar.DAY_OF_YEAR, 222, }, d[11],
+ // 12
+ new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,
+ Calendar.MONTH, Calendar.DECEMBER, }, d[12],
+ };
+
+ for (int i=0; i<FIELD_DATA.length; i+=2) {
+ int[] fields = (int[]) FIELD_DATA[i];
+ Date exp = (Date) FIELD_DATA[i+1];
+
+ cal.clear();
+ cal.set(Calendar.YEAR, Y);
+ for (int j=0; j<fields.length; j+=2) {
+ cal.set(fields[j], fields[j+1]);
+ }
+
+ Date act = cal.getTime();
+ if (!act.equals(exp)) {
+ errln("FAIL: Test " + (i/2) + " got " + act +
+ ", want " + exp +
+ " (see test/java/util/Calendar/CalendarRegression.java");
+ }
+ }
+
+ tempcal.set(1997, Calendar.JANUARY, 5);
+ d[0] = tempcal.getTime();
+ tempcal.set(1997, Calendar.JANUARY, 26);
+ d[1] = tempcal.getTime();
+ tempcal.set(1997, Calendar.FEBRUARY, 23);
+ d[2] = tempcal.getTime();
+ tempcal.set(1997, Calendar.JANUARY, 26);
+ d[3] = tempcal.getTime();
+ tempcal.set(1997, Calendar.JANUARY, 5);
+ d[4] = tempcal.getTime();
+ tempcal.set(1996, Calendar.DECEMBER, 8);
+ d[5] = tempcal.getTime();
+ // Test specific failure reported in bug
+ Object[] DATA = {
+ new Integer(1), d[0], new Integer(4), d[1],
+ new Integer(8), d[2], new Integer(-1), d[3],
+ new Integer(-4), d[4], new Integer(-8), d[5],
+ };
+ for (int i=0; i<DATA.length; i+=2) {
+ cal.clear();
+ cal.set(Calendar.DAY_OF_WEEK_IN_MONTH,
+ ((Number) DATA[i]).intValue());
+ cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
+ cal.set(Calendar.MONTH, Calendar.JANUARY);
+ cal.set(Calendar.YEAR, 1997);
+ Date actual = cal.getTime();
+ if (!actual.equals(DATA[i+1])) {
+ errln("FAIL: Sunday " + DATA[i] +
+ " of Jan 1997 -> " + actual +
+ ", want " + DATA[i+1]);
+ }
+ }
+ }
+
+ /**
+ * WEEK_OF_YEAR computed incorrectly. A failure of this test can indicate a
+ * problem in several different places in the
+ */
+ public void Test4288792() throws Exception
+ {
+ TimeZone savedTZ = TimeZone.getDefault();
+ TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+ GregorianCalendar cal = new GregorianCalendar();
+
+ for (int i = 1900; i < 2100; i++) {
+ for (int j1 = 1; j1 <= 7; j1++) {
+ // Loop for MinimalDaysInFirstWeek: 1..7
+ for (int j = Calendar.SUNDAY; j <= Calendar.SATURDAY; j++) {
+ // Loop for FirstDayOfWeek: SUNDAY..SATURDAY
+ cal.clear();
+ cal.setMinimalDaysInFirstWeek(j1);
+ cal.setFirstDayOfWeek(j);
+ // Set the calendar to the first day of the last week
+ // of the year. This may overlap some of the start of
+ // the next year; that is, the last week of 1999 may
+ // include some of January 2000. Use the add() method
+ // to advance through the week. For each day, call
+ // get(WEEK_OF_YEAR). The result should be the same
+ // for the whole week. Note that a bug in
+ // getActualMaximum() will break this test.
+ cal.set(Calendar.YEAR, i);
+ int maxWeek = cal.getActualMaximum(Calendar.WEEK_OF_YEAR);
+ cal.set(Calendar.WEEK_OF_YEAR, maxWeek);
+ cal.set(Calendar.DAY_OF_WEEK, j);
+ for (int k = 1; k < 7; k++) {
+ cal.add(Calendar.DATE, 1);
+ int WOY = cal.get(Calendar.WEEK_OF_YEAR);
+ if (WOY != maxWeek) {
+ errln(cal.getTime() + ",got=" + WOY
+ + ",expected=" + maxWeek
+ + ",min=" + j1 + ",first=" + j);
+ }
+ }
+ // Now advance the calendar one more day. This should
+ // put it at the first day of week 1 of the next year.
+ cal.add(Calendar.DATE, 1);
+ int WOY = cal.get(Calendar.WEEK_OF_YEAR);
+ if (WOY != 1) {
+ errln(cal.getTime() + ",got=" + WOY
+ + ",expected=1,min=" + j1 + ",first" + j);
+ }
+ }
+ }
+ }
+ TimeZone.setDefault(savedTZ);
+ }
+
+ /**
+ * Test fieldDifference().
+ */
+ public void TestJ438() throws Exception {
+ int DATA[] = {
+ 2000, Calendar.JANUARY, 20, 2010, Calendar.JUNE, 15,
+ 2010, Calendar.JUNE, 15, 2000, Calendar.JANUARY, 20,
+ 1964, Calendar.SEPTEMBER, 7, 1999, Calendar.JUNE, 4,
+ 1999, Calendar.JUNE, 4, 1964, Calendar.SEPTEMBER, 7,
+ };
+ Calendar cal = Calendar.getInstance(Locale.US);
+ for (int i=0; i<DATA.length; i+=6) {
+ int y1 = DATA[i];
+ int m1 = DATA[i+1];
+ int d1 = DATA[i+2];
+ int y2 = DATA[i+3];
+ int m2 = DATA[i+4];
+ int d2 = DATA[i+5];
+
+ cal.clear();
+ cal.set(y1, m1, d1);
+ Date date1 = cal.getTime();
+ cal.set(y2, m2, d2);
+ Date date2 = cal.getTime();
+
+ cal.setTime(date1);
+ int dy = cal.fieldDifference(date2, Calendar.YEAR);
+ int dm = cal.fieldDifference(date2, Calendar.MONTH);
+ int dd = cal.fieldDifference(date2, Calendar.DATE);
+
+ logln("" + date2 + " - " + date1 + " = " +
+ dy + "y " + dm + "m " + dd + "d");
+
+ cal.setTime(date1);
+ cal.add(Calendar.YEAR, dy);
+ cal.add(Calendar.MONTH, dm);
+ cal.add(Calendar.DATE, dd);
+ Date date22 = cal.getTime();
+ if (!date2.equals(date22)) {
+ errln("FAIL: " + date1 + " + " +
+ dy + "y " + dm + "m " + dd + "d = " +
+ date22 + ", exp " + date2);
+ } else {
+ logln("Ok: " + date1 + " + " +
+ dy + "y " + dm + "m " + dd + "d = " +
+ date22);
+ }
+ }
+ }
+
+ public void TestT5555() throws Exception
+ {
+ Calendar cal = Calendar.getInstance();
+
+ // Set date to Wednesday, February 21, 2007
+ cal.set(2007, Calendar.FEBRUARY, 21);
+
+ try {
+ // Advance month by three years
+ cal.add(Calendar.MONTH, 36);
+
+ // Move to last Wednesday of month.
+ cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);
+
+ cal.getTime();
+ } catch (Exception e) {
+ errln("Got an exception calling getTime().");
+ }
+
+ int yy, mm, dd, ee;
+
+ yy = cal.get(Calendar.YEAR);
+ mm = cal.get(Calendar.MONTH);
+ dd = cal.get(Calendar.DATE);
+ ee = cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);
+
+ if (yy != 2010 || mm != Calendar.FEBRUARY || dd != 24 || ee != Calendar.WEDNESDAY) {
+ errln("Got date " + yy + "/" + (mm + 1) + "/" + dd + ", expected 2010/2/24");
+ }
+ }
+
+ /**
+ * Set behavior of DST_OFFSET field. ICU4J Jitterbug 9.
+ */
+ public void TestJ9() {
+ int HOURS = 60*60*1000;
+ Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("PST"),
+ Locale.US);
+
+ final int END_FIELDS = 0x1234;
+
+ int[] DATA = {
+ // With no explicit ZONE/DST expect 12:00 am
+ Calendar.MONTH, Calendar.JUNE,
+ END_FIELDS,
+ 0, 0, // expected hour, min
+
+ // Normal ZONE/DST for June 1 Pacific is 8:00/1:00
+ Calendar.MONTH, Calendar.JUNE,
+ Calendar.ZONE_OFFSET, -8*HOURS,
+ Calendar.DST_OFFSET, HOURS,
+ END_FIELDS,
+ 0, 0, // expected hour, min
+
+ // With ZONE/DST of 8:00/0:30 expect time of 12:30 am
+ Calendar.MONTH, Calendar.JUNE,
+ Calendar.ZONE_OFFSET, -8*HOURS,
+ Calendar.DST_OFFSET, HOURS/2,
+ END_FIELDS,
+ 0, 30, // expected hour, min
+
+ // With ZONE/DST of 8:00/UNSET expect time of 1:00 am
+ Calendar.MONTH, Calendar.JUNE,
+ Calendar.ZONE_OFFSET, -8*HOURS,
+ END_FIELDS,
+ 1, 0, // expected hour, min
+
+ // With ZONE/DST of UNSET/0:30 expect 4:30 pm (day before)
+ Calendar.MONTH, Calendar.JUNE,
+ Calendar.DST_OFFSET, HOURS/2,
+ END_FIELDS,
+ 16, 30, // expected hour, min
+ };
+
+ for (int i=0; i<DATA.length; ) {
+ int start = i;
+ cal.clear();
+
+ // Set fields
+ while (DATA[i] != END_FIELDS) {
+ cal.set(DATA[i++], DATA[i++]);
+ }
+ ++i; // skip over END_FIELDS
+
+ // Get hour/minute
+ int h = cal.get(Calendar.HOUR_OF_DAY);
+ int m = cal.get(Calendar.MINUTE);
+
+ // Check
+ if (h != DATA[i] || m != DATA[i+1]) {
+ errln("Fail: expected " + DATA[i] + ":" + DATA[i+1] +
+ ", got " + h + ":" + m + " after:");
+ while (DATA[start] != END_FIELDS) {
+ logln("set(" + FIELD_NAME[DATA[start++]] +
+ ", " + DATA[start++] + ");");
+ }
+ }
+
+ i += 2; // skip over expected hour, min
+ }
+ }
+
+ /**
+ * DateFormat class mistakes date style and time style as follows: -
+ * DateFormat.getDateTimeInstance takes date style as time style, and time
+ * style as date style - If a Calendar is passed to
+ * DateFormat.getDateInstance, it returns time instance - If a Calendar is
+ * passed to DateFormat.getTimeInstance, it returns date instance
+ */
+ public void TestDateFormatFactoryJ26() {
+ TimeZone zone = TimeZone.getDefault();
+ try {
+ Locale loc = Locale.US;
+ TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
+ java.util.Calendar tempcal = java.util.Calendar.getInstance();
+ tempcal.set(2001, Calendar.APRIL, 5, 17, 43, 53);
+ Date date = tempcal.getTime();
+ Calendar cal = Calendar.getInstance(loc);
+ Object[] DATA = {
+ DateFormat.getDateInstance(DateFormat.SHORT, loc),
+ "DateFormat.getDateInstance(DateFormat.SHORT, loc)",
+ "4/5/01",
+
+ DateFormat.getTimeInstance(DateFormat.SHORT, loc),
+ "DateFormat.getTimeInstance(DateFormat.SHORT, loc)",
+ "5:43 PM",
+
+ DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc),
+ "DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, loc)",
+ "Thursday, April 5, 2001 5:43 PM",
+
+ DateFormat.getDateInstance(cal, DateFormat.SHORT, loc),
+ "DateFormat.getDateInstance(cal, DateFormat.SHORT, loc)",
+ "4/5/01",
+
+ DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc),
+ "DateFormat.getTimeInstance(cal, DateFormat.SHORT, loc)",
+ "5:43 PM",
+
+ DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc),
+ "DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.SHORT, loc)",
+ "Thursday, April 5, 2001 5:43 PM",
+
+ cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc),
+ "cal.getDateTimeFormat(DateFormat.SHORT, DateFormat.FULL, loc)",
+ "4/5/01 5:43:53 PM Pacific Daylight Time",
+
+ cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc),
+ "cal.getDateTimeFormat(DateFormat.FULL, DateFormat.SHORT, loc)",
+ "Thursday, April 5, 2001 5:43 PM",
+ };
+ for (int i=0; i<DATA.length; i+=3) {
+ DateFormat df = (DateFormat) DATA[i];
+ String desc = (String) DATA[i+1];
+ String exp = (String) DATA[i+2];
+ String got = df.format(date);
+ if (got.equals(exp)) {
+ logln("Ok: " + desc + " => " + got);
+ } else {
+ errln("FAIL: " + desc + " => " + got + ", expected " + exp);
+ }
+ }
+ } finally {
+ TimeZone.setDefault(zone);
+ }
+ }
+
+ public void TestRegistration() {
+ /*
+ * Set names = Calendar.getCalendarFactoryNames();
+ *
+ * TimeZone tz = TimeZone.getDefault(); Locale loc =
+ * Locale.getDefault(); Iterator iter = names.iterator(); while
+ * (iter.hasNext()) { String name = (String)iter.next(); logln("Testing
+ * factory: " + name);
+ *
+ * Calendar cal = Calendar.getInstance(tz, loc, name); logln("Calendar
+ * class: " + cal.getClass());
+ *
+ * DateFormat fmt = cal.getDateTimeFormat(DateFormat.LONG,
+ * DateFormat.LONG, loc);
+ *
+ * logln("Date: " + fmt.format(cal.getTime())); }
+ * // register new default for our locale logln("\nTesting
+ * registration"); loc = new Locale("en", "US"); Object key =
+ * Calendar.register(JapaneseCalendar.factory(), loc, true);
+ *
+ * loc = new Locale("en", "US", "TEST"); Calendar cal =
+ * Calendar.getInstance(loc); logln("Calendar class: " +
+ * cal.getClass()); DateFormat fmt =
+ * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);
+ * logln("Date: " + fmt.format(cal.getTime()));
+ * // force to use other default anyway logln("\nOverride
+ * registration"); cal = Calendar.getInstance(tz, loc, "Gregorian"); fmt =
+ * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);
+ * logln("Date: " + fmt.format(cal.getTime()));
+ * // unregister default logln("\nUnregistration"); logln("Unregister
+ * returned: " + Calendar.unregister(key)); cal =
+ * Calendar.getInstance(tz, loc, "Gregorian"); fmt =
+ * cal.getDateTimeFormat(DateFormat.LONG, DateFormat.LONG, loc);
+ * logln("Date: " + fmt.format(cal.getTime()));
+ */
+ }
+
+ /**
+ * test serialize-and-modify.
+ * @throws ClassNotFoundException
+ */
+ public void TestSerialization3474() {
+ try {
+ ByteArrayOutputStream icuStream = new ByteArrayOutputStream();
+
+ logln("icu Calendar");
+
+ com.ibm.icu.util.GregorianCalendar icuCalendar =
+ new com.ibm.icu.util.GregorianCalendar();
+
+ icuCalendar.setTimeInMillis(1187912555931L);
+ long expectMillis = 1187912520931L; // with seconds (not ms) cleared.
+
+ logln("instantiated: "+icuCalendar);
+ logln("getMillis: "+icuCalendar.getTimeInMillis());
+ icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);
+ logln("setSecond=0: "+icuCalendar);
+ {
+ long gotMillis = icuCalendar.getTimeInMillis();
+ if(gotMillis != expectMillis) {
+ errln("expect millis "+expectMillis+" but got "+gotMillis);
+ } else {
+ logln("getMillis: "+gotMillis);
+ }
+ }
+ ObjectOutputStream icuOut =
+ new ObjectOutputStream(icuStream);
+ icuOut.writeObject(icuCalendar);
+ icuOut.flush();
+ icuOut.close();
+
+ ObjectInputStream icuIn =
+ new ObjectInputStream(new ByteArrayInputStream(icuStream.toByteArray()));
+ icuCalendar = null;
+ icuCalendar = (com.ibm.icu.util.GregorianCalendar)icuIn.readObject();
+
+ logln("serialized back in: "+icuCalendar);
+ {
+ long gotMillis = icuCalendar.getTimeInMillis();
+ if(gotMillis != expectMillis) {
+ errln("expect millis "+expectMillis+" but got "+gotMillis);
+ } else {
+ logln("getMillis: "+gotMillis);
+ }
+ }
+
+ icuCalendar.set(com.ibm.icu.util.GregorianCalendar.SECOND, 0);
+
+ logln("setSecond=0: "+icuCalendar);
+ {
+ long gotMillis = icuCalendar.getTimeInMillis();
+ if(gotMillis != expectMillis) {
+ errln("expect millis "+expectMillis+" after stream and setSecond but got "+gotMillis);
+ } else {
+ logln("getMillis after stream and setSecond: "+gotMillis);
+ }
+ }
+ } catch(IOException e) {
+ errln(e.toString());
+ e.printStackTrace();
+ } catch(ClassNotFoundException cnf) {
+ errln(cnf.toString());
+ cnf.printStackTrace();
+ }
+
+ // JDK works correctly, etc etc.
+// ByteArrayOutputStream jdkStream = new ByteArrayOutputStream();
+
+// logln("\nSUN Calendar");
+//
+// java.util.GregorianCalendar sunCalendar =
+// new java.util.GregorianCalendar();
+//
+// logln("instanzieren: "+sunCalendar);
+// logln("getMillis: "+sunCalendar.getTimeInMillis());
+// sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);
+// logln("setSecond=0: "+sunCalendar);
+// logln("getMillis: "+sunCalendar.getTimeInMillis());
+//
+// ObjectOutputStream sunOut =
+// new ObjectOutputStream(jdkStream);
+// sunOut.writeObject(sunCalendar);
+// sunOut.flush();
+// sunOut.close();
+//
+// ObjectInputStream sunIn =
+// new ObjectInputStream(new ByteArrayInputStream(jdkStream.toByteArray()));
+// sunCalendar = null;
+// sunCalendar = (java.util.GregorianCalendar)sunIn.readObject();
+//
+// logln("serialized: "+sunCalendar);
+// logln("getMillis: "+sunCalendar.getTimeInMillis());
+//
+// sunCalendar.set(java.util.GregorianCalendar.SECOND, 0);
+// logln("setSecond=0: "+sunCalendar);
+// logln("getMillis: "+sunCalendar.getTimeInMillis());
+
+ }
+
+ public void TestYearJump3279() {
+ final long time = 1041148800000L;
+ Calendar c = new GregorianCalendar();
+ DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.US);
+
+ c.setTimeInMillis(time);
+ int year1 = c.get(Calendar.YEAR);
+
+ logln("time: " + fmt.format(new Date(c.getTimeInMillis())));
+
+ logln("setting DOW to " + c.getFirstDayOfWeek());
+ c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
+ logln("week: " + c.getTime());
+ logln("week adjust: " + fmt.format(new Date(c.getTimeInMillis())));
+ int year2 = c.get(Calendar.YEAR);
+
+ if(year1 != year2) {
+ errln("Error: adjusted day of week, and year jumped from " + year1 + " to " + year2);
+ } else {
+ logln("Year remained " + year2 + " - PASS.");
+ }
+ }
+
+ public void TestGetKeywordValuesForLocale(){
+
+ final String[][] PREFERRED = {
+ {"root", "gregorian"},
+ {"und", "gregorian"},
+ {"en_US", "gregorian"},
+ {"en_029", "gregorian"},
+ {"th_TH", "buddhist", "gregorian"},
+ {"und_TH", "buddhist", "gregorian"},
+ {"en_TH", "buddhist", "gregorian"},
+ {"he_IL", "gregorian", "hebrew", "islamic", "islamic-civil"},
+ {"ar_EG", "gregorian", "coptic", "islamic", "islamic-civil"},
+ {"ja", "gregorian", "japanese"},
+ {"ps_Guru_IN", "gregorian", "indian"},
+ {"th@calendar=gregorian", "buddhist", "gregorian"},
+ {"en@calendar=islamic", "gregorian"},
+ {"zh_TW", "gregorian", "roc", "chinese"},
+ {"ar_IR", "gregorian", "persian", "islamic", "islamic-civil"},
+ };
+
+ String[] ALL = Calendar.getKeywordValuesForLocale("calendar", ULocale.getDefault(), false);
+ HashSet ALLSET = new HashSet();
+ for (int i = 0; i < ALL.length; i++) {
+ ALLSET.add(ALL[i]);
+ }
+
+ for (int i = 0; i < PREFERRED.length; i++) {
+ ULocale loc = new ULocale(PREFERRED[i][0]);
+ String[] expected = new String[PREFERRED[i].length - 1];
+ System.arraycopy(PREFERRED[i], 1, expected, 0, expected.length);
+
+ String[] pref = Calendar.getKeywordValuesForLocale("calendar", loc, true);
+ boolean matchPref = false;
+ if (pref.length == expected.length) {
+ matchPref = true;
+ for (int j = 0; j < pref.length; j++) {
+ if (!pref[j].equals(expected[j])) {
+ matchPref = false;
+ }
+ }
+ }
+ if (!matchPref) {
+ errln("FAIL: Preferred values for locale " + loc
+ + " got:" + Utility.arrayToString(pref) + " expected:" + Utility.arrayToString(expected));
+ }
+
+ String[] all = Calendar.getKeywordValuesForLocale("calendar", loc, false);
+ boolean matchAll = false;
+ if (all.length == ALLSET.size()) {
+ matchAll = true;
+ for (int j = 0; j < all.length; j++) {
+ if (!ALLSET.contains(all[j])) {
+ matchAll = false;
+ break;
+ }
+ }
+ }
+ if (!matchAll) {
+ errln("FAIL: All values for locale " + loc
+ + " got:" + Utility.arrayToString(all));
+ }
+ }
+ }
+
+}
+
+//eof
projects / Dictionary.git / blobdiff