package com.ibm.test.calendar;
import com.ibm.util.*;
import java.util.Date;
import java.util.Locale;
import com.ibm.text.*;

/**
 * @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.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() {
        // 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() + " " +
                      cal.get(Calendar.DST_OFFSET) / (60*60*1000) + " " +
                      zone.getRawOffset() / (60*60*1000) +
                      ": HOUR = " + cal.get(Calendar.HOUR));
                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");
    }

    public void Test4035301() {
        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");
    }

    public void Test4040996() {
        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");
    }

    public void Test4051765() {
        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;
        }
    }
    
    /* 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() {
        GregorianCalendar gc = new GregorianCalendar();
        
        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();
        Date exp = new Date(97, 3, 1, 0, 0, 0);
        if (!cd.equals(exp))
            errln("Fail: Calendar.set broken. Got " + cd + " Want " + exp);
    }

    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) {;}
        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() {
        Date d = getAssociatedDate(new Date(98, 0, 30));
        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 date 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() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date(98, Calendar.JUNE, 24));
        cal.set(Calendar.MONTH, Calendar.NOVEMBER); // change a field
        logln(cal.getTime().toString());
        if (!cal.getTime().equals(new Date(98, Calendar.NOVEMBER, 24)))
            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++ ); 

        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(cal1.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(cal1.HOUR_OF_DAY)));
        cal1.setTime(new Date(880698639000L));
        logln("GMT 2 is: " + (h2=cal1.get(cal1.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(cal1.YEAR),
                 cal1.get(cal1.MONTH),
                 cal1.get(cal1.DAY_OF_MONTH),
                 cal1.get(cal1.HOUR_OF_DAY),
                 cal1.get(cal1.MINUTE),
                 cal1.get(cal1.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(cal1.YEAR),
                 cal1.get(cal1.MONTH),
                 cal1.get(cal1.DAY_OF_MONTH),
                 cal1.get(cal1.HOUR_OF_DAY),
                 cal1.get(cal1.MINUTE),
                 cal1.get(cal1.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);
            }
        }

        // 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),
                new Date(97, Calendar.DECEMBER, 28),
            new Integer(1998), new Integer(2), new Integer(Calendar.SATURDAY),
                new Date(98, Calendar.JANUARY, 10),
            new Integer(1998), new Integer(53), new Integer(Calendar.THURSDAY),
                new Date(98, Calendar.DECEMBER, 31),
            new Integer(1998), new Integer(53), new Integer(Calendar.FRIDAY),
                new Date(99, Calendar.JANUARY, 1),
        };
        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();
        Object[] ADDROLL = {
            ADD, new Integer(1), new Date(98, Calendar.DECEMBER, 25), new Date(99, Calendar.JANUARY, 1),
            ADD, new Integer(1), new Date(97, Calendar.DECEMBER, 28), new Date(98, Calendar.JANUARY, 4),
            ROLL, new Integer(1), new Date(98, Calendar.DECEMBER, 27), new Date(97, Calendar.DECEMBER, 28),
            ROLL, new Integer(1), new Date(99, Calendar.JANUARY, 2), new Date(98, Calendar.JANUARY, 3),
        };
        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();
        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: No locales for " + locales[i]);
                }
            }
        }
        finally {
            Locale.setDefault(saveLocale);
        }
    }

    public void Test4108764() {
        Date d00 = new Date(97, Calendar.MARCH, 15, 12, 00, 00);
        Date d01 = new Date(97, Calendar.MARCH, 15, 12, 00, 56);
        Date d10 = new Date(97, Calendar.MARCH, 15, 12, 34, 00);
        Date d11 = new Date(97, Calendar.MARCH, 15, 12, 34, 56);
        Date dM  = new Date(97, Calendar.JANUARY, 15, 12, 34, 56);
        Date epoch = new Date(70, Calendar.JANUARY, 1);

        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());

        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());
        }
    }

    public void Test4114578() {
        int ONE_HOUR = 60*60*1000;
        Calendar cal = Calendar.getInstance();
        cal.setTimeZone(TimeZone.getTimeZone("PST"));
        long onset = new Date(98, Calendar.APRIL, 5, 1, 0).getTime() + ONE_HOUR;
        long cease = new Date(98, Calendar.OCTOBER, 25, 0, 0).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.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");
        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");
        }

        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
        b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset() + 60*60*1000);
        if (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");
        }
        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);
        Date date = new Date(1996-1900, Calendar.JANUARY, 3); // Arbitrary date
        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) {} 
        }
    }

    /**
     * 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]);
                        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();
        int d1 = calendar.get(Calendar.DAY_OF_MONTH);

        calendar = new GregorianCalendar(1996, 1, 29);
        calendar.add(Calendar.MONTH, 11); 
        Date date2 = calendar.getTime();
        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 - 1900;

        Object[] FIELD_DATA = {
            // Add new test cases as needed.

            // 0
            new int[] {}, new Date(Y, Calendar.JANUARY, 1),
            // 1
            new int[] { Calendar.MONTH, Calendar.MARCH },
            new Date(Y, Calendar.MARCH, 1),
            // 2
            new int[] { Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY },
            new Date(Y, Calendar.JANUARY, 4),
            // 3
            new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,
                        Calendar.DAY_OF_MONTH, 18, },
            new Date(Y, Calendar.JANUARY, 18),
            // 4
            new int[] { Calendar.DAY_OF_MONTH, 18,
                        Calendar.DAY_OF_WEEK, Calendar.THURSDAY, },
            new Date(Y, Calendar.JANUARY, 18),
            // 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, },
            new Date(Y-1, Calendar.DECEMBER, 22),
            // 6
            new int[] { Calendar.DAY_OF_MONTH, 18,
                        Calendar.WEEK_OF_MONTH, 4,
                        Calendar.DAY_OF_WEEK, Calendar.THURSDAY, },
            new Date(Y, Calendar.JANUARY, 26),
            // 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, },
            new Date(Y, Calendar.JANUARY, 26),
            // 8
            new int[] { Calendar.WEEK_OF_YEAR, 9,
                        Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY, },
            new Date(Y, Calendar.MARCH, 1),
            // 9
            new int[] { Calendar.MONTH, Calendar.OCTOBER,
                        Calendar.DAY_OF_WEEK_IN_MONTH, 1,
                        Calendar.DAY_OF_WEEK, Calendar.FRIDAY, },
            new Date(Y, Calendar.OCTOBER, 6),
            // 10
            new int[] { Calendar.MONTH, Calendar.OCTOBER,
                        Calendar.WEEK_OF_MONTH, 2,
                        Calendar.DAY_OF_WEEK, Calendar.FRIDAY, },
            new Date(Y, Calendar.OCTOBER, 13),
            // 11
            new int[] { Calendar.MONTH, Calendar.OCTOBER,
                        Calendar.DAY_OF_MONTH, 15,
                        Calendar.DAY_OF_YEAR, 222, },
            new Date(Y, Calendar.AUGUST, 10),
            // 12
            new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,
                        Calendar.MONTH, Calendar.DECEMBER, },
            new Date(Y, Calendar.DECEMBER, 7),
        };

        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 + 1900);
            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");
            }
        }

        // Test specific failure reported in bug
        Object[] DATA = {
            new Integer(1), new Date(1997-1900, Calendar.JANUARY, 5),
            new Integer(4), new Date(1997-1900, Calendar.JANUARY, 26),
            new Integer(8), new Date(1997-1900, Calendar.FEBRUARY, 23),
            new Integer(-1), new Date(1997-1900, Calendar.JANUARY, 26),
            new Integer(-4), new Date(1997-1900, Calendar.JANUARY, 5),
            new Integer(-8), new Date(1996-1900, Calendar.DECEMBER, 8),
        };
        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);
            }
        }
    }

    /**
     * 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
        }
    }
}

//eof