/*
 * Copyright (c) 1998, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @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 4328747 4413980 4546637 4623997
 * 4685354 4655637 4683492 4080631 4080631 4167995 4340146 4639407
 * 4652815 4652830 4740554 4936355 4738710 4633646 4846659 4822110 4960642
 * 4973919 4980088 4965624 5013094 5006864 8152077
 * @library /java/text/testlib
 * @run main CalendarRegression
 */
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.SimpleTimeZone;
import java.util.TimeZone;

import static java.util.Calendar.*;

public class CalendarRegression extends IntlTest {

    public static void main(String[] args) throws Exception {
        new CalendarRegression().run(args);
    }

    /*
    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(HOUR) != 5) {
                logln(zone.getID() + " "
                        + //zone.useDaylightTime() + " "
                        + cal.get(DST_OFFSET) / (60 * 60 * 1000) + " "
                        + zone.getRawOffset() / (60 * 60 * 1000)
                        + ": HOUR = " + cal.get(HOUR));
                bad = true;
            }
        }
        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(APRIL, 1, SUNDAY, 2 * 60 * 60 * 1000);
        pdt.setEndRule(OCTOBER, -1, SUNDAY, 2 * 60 * 60 * 1000);
        Calendar calendar = new GregorianCalendar(pdt);

        calendar.set(MONTH, 3);
        calendar.set(DAY_OF_MONTH, 18);
        calendar.set(SECOND, 30);

        logln("MONTH: " + calendar.get(MONTH));
        logln("DAY_OF_MONTH: "
                + calendar.get(DAY_OF_MONTH));
        logln("MINUTE: " + calendar.get(MINUTE));
        logln("SECOND: " + calendar.get(SECOND));

        calendar.add(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(MONTH));
        logln("DAY_OF_MONTH: "
                + calendar.get(DAY_OF_MONTH));
        logln("MINUTE: " + calendar.get(MINUTE));
        logln("SECOND: " + calendar.get(SECOND));
        if (calendar.get(MONTH) != 3
                || calendar.get(DAY_OF_MONTH) != 18
                || calendar.get(SECOND) != 36) {
            errln("Fail: Calendar.add misbehaves");
        }
    }

    public void Test4051765() {
        Calendar cal = Calendar.getInstance();
        cal.setLenient(false);
        cal.set(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(HOUR, 0);
        gc.set(AM_PM, AM);
        gc.set(MINUTE, 0);
        gc.set(SECOND, 0);
        gc.set(MILLISECOND, 0);

        Date cd = gc.getTime();
        @SuppressWarnings("deprecation")
        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(HOUR_OF_DAY, 13);
        logln("Hour: " + cal.get(HOUR_OF_DAY));
        cal.add(HOUR_OF_DAY, 6);
        logln("Hour: " + cal.get(HOUR_OF_DAY));
        if (cal.get(HOUR_OF_DAY) != 19) {
            errln("Fail: Want 19 Got " + cal.get(HOUR_OF_DAY));
        }
    }

    public void Test4070502() {
        @SuppressWarnings("deprecation")
        Date d = getAssociatedDate(new Date(98, 0, 30));
        Calendar cal = new GregorianCalendar();
        cal.setTime(d);
        if (cal.get(DAY_OF_WEEK) == SATURDAY
                || cal.get(DAY_OF_WEEK) == 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(DAY_OF_WEEK);
            if (wd == SATURDAY || wd == SUNDAY) {
                cal.add(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, AUGUST, 12); // Wednesday
        // cal.getTime(); // Force update
        cal.setLenient(lenient);
        cal.set(1996, DECEMBER, 1); // Set the date to be December 1, 1996
        int dow = cal.get(DAY_OF_WEEK);
        int min = cal.getMinimum(DAY_OF_WEEK);
        int max = cal.getMaximum(DAY_OF_WEEK);
        logln(cal.getTime().toString());
        if (min != SUNDAY || max != SATURDAY) {
            errln("FAIL: Min/max bad");
        }
        if (dow < min || dow > max) {
            errln("FAIL: Day of week " + dow + " out of range");
        }
        if (dow != SUNDAY) {
            errln("FAIL: Day of week should be SUNDAY Got " + dow);
        }
    }

    @SuppressWarnings("deprecation")
    public void Test4071385() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date(98, JUNE, 24));
        cal.set(MONTH, NOVEMBER); // change a field
        logln(cal.getTime().toString());
        if (!cal.getTime().equals(new Date(98, NOVEMBER, 24))) {
            errln("Fail");
        }
    }

    public void Test4073929() {
        GregorianCalendar foo1 = new GregorianCalendar(1997, 8, 27);
        foo1.add(DAY_OF_MONTH, +1);
        int testyear = foo1.get(YEAR);
        int testmonth = foo1.get(MONTH);
        int testday = foo1.get(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(HOUR_OF_DAY) * 3600000L
                    + cal.get(MINUTE) * 60000L
                    + cal.get(SECOND) * 1000L
                    + cal.get(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(HOUR_OF_DAY) * 3600000L
                        + cal.get(MINUTE) * 60000L
                        + cal.get(SECOND) * 1000L
                        + cal.get(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();

        String summerTime = "British Summer Time";
        String standardTime = "Greenwich Mean Time";
        try {
            Locale.setDefault(Locale.UK);
            TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
            date = new SimpleDateFormat("zzzz");

            Calendar cal = Calendar.getInstance();
            cal.set(1997, SEPTEMBER, 30);
            Date now = cal.getTime();
            String formattedDate = date.format(now);
            if (!formattedDate.equals(summerTime)) {
                errln("Wrong display name \"" + formattedDate
                        + "\" for <" + now + ">");
            }
            int weekOfYear = cal.get(WEEK_OF_YEAR);
            if (weekOfYear != 40) {
                errln("Wrong week-of-year " + weekOfYear
                        + " for <" + now + ">");
            }

            cal.set(1996, DECEMBER, 31);
            now = cal.getTime();
            formattedDate = date.format(now);
            if (!formattedDate.equals(standardTime)) {
                errln("Wrong display name \"" + formattedDate
                        + "\" for <" + now + ">");
            }
            weekOfYear = cal.get(WEEK_OF_YEAR);
            if (weekOfYear != 1) {
                errln("Wrong week-of-year " + weekOfYear
                        + " for <" + now + ">");
            }

            cal.set(1997, JANUARY, 1);
            now = cal.getTime();
            formattedDate = date.format(now);
            if (!formattedDate.equals(standardTime)) {
                errln("Wrong display name \"" + formattedDate
                        + "\" for <" + now + ">");
            }
            weekOfYear = cal.get(WEEK_OF_YEAR);
            if (weekOfYear != 1) {
                errln("Wrong week-of-year " + weekOfYear
                        + " for <" + now + ">");
            }

            cal.set(1997, JANUARY, 8);
            now = cal.getTime();
            formattedDate = date.format(now);
            if (!formattedDate.equals(standardTime)) {
                errln("Wrong display name \"" + formattedDate
                        + "\" for <" + now + ">");
            }
            weekOfYear = cal.get(WEEK_OF_YEAR);
            if (weekOfYear != 2) {
                errln("Wrong week-of-year " + weekOfYear
                        + " for <" + now + ">");
            }

        } finally {
            Locale.setDefault(saveLocale);
            TimeZone.setDefault(saveZone);
        }
    }

    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(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(MILLISECOND));
        if (!cal1.equals(cal2)) {
            errln("Fail: Milliseconds randomized");
        }
    }

    public void Test4095407() {
        GregorianCalendar a = new GregorianCalendar(1997, NOVEMBER, 13);
        int dow = a.get(DAY_OF_WEEK);
        if (dow != 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(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(HOUR_OF_DAY)));
        cal1.setTime(new Date(880698639000L));
        logln("GMT 2 is: " + (h2 = cal1.get(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(MILLISECOND, 0);
        cal3.set(MILLISECOND, 0);

        cal2.set(cal1.get(YEAR),
                cal1.get(MONTH),
                cal1.get(DAY_OF_MONTH),
                cal1.get(HOUR_OF_DAY),
                cal1.get(MINUTE),
                cal1.get(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(YEAR),
                cal1.get(MONTH),
                cal1.get(DAY_OF_MONTH),
                cal1.get(HOUR_OF_DAY),
                cal1.get(MINUTE),
                cal1.get(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(MONTH) + 1) + "/"
                    + gc.get(DATE) + "/" + gc.get(YEAR)
                    + " + 1mo = ");

            gc.add(MONTH, 1);
            logln((m2 = gc.get(MONTH) + 1) + "/"
                    + gc.get(DATE) + "/" + gc.get(YEAR)
            );
            int m = (m1 % 12) + 1;
            if (m2 != m) {
                errln("Fail: Want " + m + " Got " + m2);
            }
        }

    }

    public void Test4100311() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
        cal.set(YEAR, 1997);
        cal.set(DAY_OF_YEAR, 1);
        Date d = cal.getTime();             // Should be Jan 1
        logln(d.toString());
        if (cal.get(DAY_OF_YEAR) != 1) {
            errln("Fail: DAY_OF_YEAR not set");
        }
    }

    public void Test4103271() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        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(DATE, 1);
                        String calWOY;
                        int actWOY = testCal.get(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(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, DECEMBER, 21);
            for (int i = 0; i < 21; ++i) {
                int woy = testCal.get(WEEK_OF_YEAR);
                log("\t" + testCal.getTime() + " " + woy);
                if (woy != DATA[j + 1 + i]) {
                    log(" ERROR");
                    fail = true;
                } else {
                    logln(" OK");
                }

                // 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(YEAR, DATA[j + 1 + i] < 25 ? 1998 : 1997);
                testCal.set(WEEK_OF_YEAR, DATA[j + 1 + i]);
                testCal.set(DAY_OF_WEEK, (i % 7) + SUNDAY);
                if (!testCal.getTime().equals(save)) {
                    logln("  Parse failed: " + testCal.getTime());
                    fail = true;
                } else {
                    logln("  Passed");
                }

                testCal.setTime(save);
                testCal.add(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.
        @SuppressWarnings("deprecation")
        Object[] DISAM = {
            1998, 1, SUNDAY,
            new Date(97, DECEMBER, 28),
            1998, 2, SATURDAY,
            new Date(98, JANUARY, 10),
            1998, 53, THURSDAY,
            new Date(98, DECEMBER, 31),
            1998, 53, FRIDAY,
            new Date(99, JANUARY, 1)};
        testCal.setMinimalDaysInFirstWeek(3);
        testCal.setFirstDayOfWeek(SUNDAY);
        for (int i = 0; i < DISAM.length; i += 4) {
            int y = (Integer) DISAM[i];
            int woy = (Integer) DISAM[i + 1];
            int dow = (Integer) DISAM[i + 2];
            Date exp = (Date) DISAM[i + 3];
            testCal.clear();
            testCal.set(YEAR, y);
            testCal.set(WEEK_OF_YEAR, woy);
            testCal.set(DAY_OF_WEEK, dow);
            log(y + "-W" + woy + "-DOW" + dow);
            if (!testCal.getTime().equals(exp)) {
                logln("  FAILED expect: " + exp + "\n            got: " + testCal.getTime());
                fail = true;
            } else {
                logln("  OK");
            }
        }

        // Now try adding and rolling
        Object ADD = new Object();
        Object ROLL = new Object();
        @SuppressWarnings("deprecation")
        Object[] ADDROLL = {
            ADD, 1, new Date(98, DECEMBER, 25), new Date(99, JANUARY, 1),
            ADD, 1, new Date(97, DECEMBER, 28), new Date(98, JANUARY, 4),
            ROLL, 1, new Date(98, DECEMBER, 27), new Date(98, JANUARY, 4),
            ROLL, 1, new Date(99, DECEMBER, 24), new Date(99, DECEMBER, 31),
            ROLL, 1, new Date(99, DECEMBER, 25), new Date(99, JANUARY, 9)};
        testCal.setMinimalDaysInFirstWeek(3);
        testCal.setFirstDayOfWeek(SUNDAY);
        for (int i = 0; i < ADDROLL.length; i += 4) {
            int amount = (Integer) ADDROLL[i + 1];
            Date before = (Date) ADDROLL[i + 2];
            Date after = (Date) ADDROLL[i + 3];

            testCal.setTime(before);
            if (ADDROLL[i] == ADD) {
                testCal.add(WEEK_OF_YEAR, amount);
            } else {
                testCal.roll(WEEK_OF_YEAR, amount);
            }
            log((ADDROLL[i] == ADD ? "add(WOY," : "roll(WOY,")
                    + amount + ")\t     " + before
                    + "\n\t\t  => " + testCal.getTime());
            if (!after.equals(testCal.getTime())) {
                logln("\tFAIL\n\t\texp: " + after);
                fail = true;
            } else {
                logln("  OK");
            }

            testCal.setTime(after);
            if (ADDROLL[i] == ADD) {
                testCal.add(WEEK_OF_YEAR, -amount);
            } else {
                testCal.roll(WEEK_OF_YEAR, -amount);
            }
            log((ADDROLL[i] == ADD ? "add(WOY," : "roll(WOY,")
                    + (-amount) + ")     " + after
                    + "\n\t\t  => " + testCal.getTime());
            if (!before.equals(testCal.getTime())) {
                logln("\tFAIL\n\t\texp: " + before);
                fail = true;
            } else {
                logln("\tOK");
            }
        }

        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 = {
                    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);
        }
    }

    @SuppressWarnings("deprecation")
    public void Test4108764() {
        Date d00 = new Date(97, MARCH, 15, 12, 00, 00);
        Date d01 = new Date(97, MARCH, 15, 12, 00, 56);
        Date d10 = new Date(97, MARCH, 15, 12, 34, 00);
        Date d11 = new Date(97, MARCH, 15, 12, 34, 56);
        Date epoch = new Date(70, JANUARY, 1);

        Calendar cal = Calendar.getInstance();
        cal.setTime(d11);

        cal.clear(MINUTE);
        logln(cal.getTime().toString());
        if (!cal.getTime().equals(d01)) {
            errln("Fail: clear(MINUTE) broken");
        }

        cal.set(SECOND, 0);
        logln(cal.getTime().toString());
        if (!cal.getTime().equals(d00)) {
            errln("Fail: set(SECOND, 0) broken");
        }

        cal.setTime(d11);
        cal.set(SECOND, 0);
        logln(cal.getTime().toString());
        if (!cal.getTime().equals(d10)) {
            errln("Fail: set(SECOND, 0) broken #2");
        }

        cal.clear(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: clear() broken Want " + epoch);
        }
    }

    @SuppressWarnings("deprecation")
    public void Test4114578() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        int ONE_HOUR = 60 * 60 * 1000;
        TimeZone saveZone = TimeZone.getDefault();
        boolean fail = false;
        try {
            TimeZone.setDefault(TimeZone.getTimeZone("PST"));
            Calendar cal = Calendar.getInstance();
            long onset = new Date(98, APRIL, 5, 1, 0).getTime() + ONE_HOUR;
            long cease = new Date(98, OCTOBER, 25, 0, 0).getTime() + 2 * ONE_HOUR;

            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,
                // roll() was changed to support wall-clock-based roll (JDK-8152077). The
                // time value may jump 2 hours by skipping non-existent wall-clock time.
                // Note that JDK-4114578 was a problem of add(), not roll().
                cease - ONE_HOUR,   ROLL,     1,     ONE_HOUR * 2,
                cease,              ROLL,    -1,    -ONE_HOUR * 2};

            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(HOUR, amt);
                        break;
                    case ROLL:
                        log(" roll(HOUR," + (amt < 0 ? "" : "+") + amt + ")= ");
                        cal.roll(HOUR, amt);
                        break;
                }

                log(cal.getTime().toString());

                long change = cal.getTime().getTime() - date.getTime();
                if (change != expectedChange) {
                    fail = true;
                    logln(" FAIL");
                } else {
                    logln(" OK");
                }
            }
        } finally {
            TimeZone.setDefault(saveZone);
        }

        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(HOUR) != 11
                || cal.getLeastMaximum(HOUR) != 11
                || cal.getActualMaximum(HOUR) != 11) {
            errln("Fail: maximum of HOUR field should be 11");
        }
    }

    /**
     * Check isLeapYear for BC years.
     */
    public void Test4125881() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
        DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");
        cal.clear();
        for (int y = -20; y <= 10; ++y) {
            cal.set(ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);
            cal.set(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");
            }
        }
    }

    /**
     * Prove that GregorianCalendar is proleptic (it used to cut off
     * at 45 BC, and not have leap years before then).
     */
    public void Test4125892() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
        DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");
        cal.clear();
        cal.set(ERA, GregorianCalendar.BC);
        cal.set(YEAR, 81); // 81 BC is a leap year (proleptically)
        cal.set(MONTH, FEBRUARY);
        cal.set(DATE, 28);
        cal.add(DATE, 1);
        if (cal.get(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(YEAR);
        int era1 = calendar.get(ERA);

        calendar.setTime(new Date(Long.MAX_VALUE));
        int year2 = calendar.get(YEAR);
        int era2 = calendar.get(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(YEAR);
            int maxYear = calendar.getMaximum(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() {
        final String[] fieldName = {
            "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"};
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setLenient(false);
        @SuppressWarnings("deprecation")
        Date date = new Date(1996 - 1900, JANUARY, 3); // Arbitrary date
        for (int field = 0; field < FIELD_COUNT; 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 " + fieldName[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(ERA) != GregorianCalendar.BC) {
                errln("Fail: Date(Long.MIN_VALUE) has an AD year in " + zones[i]);
            }
            calendar.setTime(new Date(Long.MAX_VALUE));
            if (calendar.get(ERA) != GregorianCalendar.AD) {
                errln("Fail: Date(Long.MAX_VALUE) has a BC year in " + zones[i]);
            }

            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 Date(Long.MAX_VALUE)");
                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 savedTz = TimeZone.getDefault();
        TimeZone tz = TimeZone.getTimeZone("PST");
        TimeZone.setDefault(tz);
        GregorianCalendar cal = new GregorianCalendar(tz);
        Date d;

        try {
            for (int i = 0; i < 5; ++i) {
                if (i > 0) {
                    logln("---");
                }

                cal.clear();
                cal.set(1998, APRIL, 5, i, 0);
                d = cal.getTime();
                String s0 = d.toString();
                logln("0 " + i + ": " + s0);

                cal.clear();
                cal.set(1998, APRIL, 4, i + 24, 0);
                d = cal.getTime();
                String sPlus = d.toString();
                logln("+ " + i + ": " + sPlus);

                cal.clear();
                cal.set(1998, 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");
                }
            }
        } finally {
            TimeZone.setDefault(savedTz);
        }
    }

    /**
     * Adding 12 months behaves differently from adding 1 year
     */
    public void Test4165343() {
        GregorianCalendar calendar = new GregorianCalendar(1996, FEBRUARY, 29);
        Date start = calendar.getTime();
        logln("init date: " + start);
        calendar.add(MONTH, 12);
        Date date1 = calendar.getTime();
        logln("after adding 12 months: " + date1);
        calendar.setTime(start);
        calendar.add(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 = WEEK_OF_MONTH;

        GregorianCalendar calendar = new GregorianCalendar(Locale.US);
        calendar.set(1998, MARCH, 1);
        calendar.setMinimalDaysInFirstWeek(1);
        logln("Date:  " + calendar.getTime());

        int firstInMonth = calendar.get(DAY_OF_MONTH);

        for (int firstInWeek = SUNDAY; firstInWeek <= 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.
     *
     * Note: Before 1.5, this test case assumed that
     * setGregorianChange didn't change object's date. But it was
     * changed. See 4928615.
     */
    public void Test4167060() {
        int field = YEAR;
        DateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy G",
                Locale.US);

        int[][] dates = {
            // year, month, day of month
            {100, NOVEMBER, 1},
            {-99 /*100BC*/, JANUARY, 1},
            {1996, FEBRUARY, 29}};

        String[] id = {"Hybrid", "Gregorian", "Julian"};

        for (int k = 0; k < 3; ++k) {
            logln("--- " + id[k] + " ---");

            for (int j = 0; j < dates.length; ++j) {
                GregorianCalendar calendar = new GregorianCalendar();
                if (k == 1) {
                    calendar.setGregorianChange(new Date(Long.MIN_VALUE));
                } else if (k == 2) {
                    calendar.setGregorianChange(new Date(Long.MAX_VALUE));
                }
                calendar.set(dates[j][0], dates[j][1], dates[j][2]);
                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]) {
                        errln("  FAIL: " + newYear + " should be invalid");
                    }
                }
            }
        }
    }

    /**
     * Calendar.roll broken
     * This bug relies on the TimeZone bug 4173604 to also be fixed.
     */
    public void Test4173516() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        int[][] fieldsList = {
            {1997, FEBRUARY, 1, 10, 45, 15, 900},
            {1999, DECEMBER, 22, 23, 59, 59, 999},
            // test case for 4960642 with default cutover
            {1582, OCTOBER, 4, 23, 59, 59, 999}};
        String[] fieldNames = {
            "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"};

        Locale savedLocale = Locale.getDefault();
        Locale.setDefault(Locale.US);
        int limit = 40;

        try {
            GregorianCalendar cal = new GregorianCalendar();

            cal.setTime(new Date(0));
            cal.roll(HOUR, 0x7F000000);
            cal.roll(HOUR, -0x7F000000);
            if (cal.getTime().getTime() != 0) {
                errln("Hour rolling broken. expected 0, got " + cal.getTime().getTime());
            }

            for (int op = 0; op < 2; ++op) {
                logln("Testing GregorianCalendar " + (op == 0 ? "add" : "roll"));

                for (int field = 0; field < FIELD_COUNT; ++field) {
                    if (field != ZONE_OFFSET
                            && field != 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(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(YEAR) != fields[0]
                                    || cal.get(MONTH) != fields[1]
                                    || cal.get(DATE) != fields[2]
                                    || cal.get(HOUR_OF_DAY) != fields[3]
                                    || cal.get(MINUTE) != fields[4]
                                    || cal.get(SECOND) != fields[5]
                                    || cal.get(MILLISECOND) != fields[6]) {
                                errln("Field " + field
                                        + " (" + fieldNames[field]
                                        + ") FAIL, expected "
                                        + fields[0]
                                        + "/" + (fields[1] + 1)
                                        + "/" + fields[2]
                                        + " " + fields[3]
                                        + ":" + fields[4]
                                        + ":" + fields[5]
                                        + "." + fields[6]
                                        + ", got " + cal.get(YEAR)
                                        + "/" + (cal.get(MONTH) + 1)
                                        + "/" + cal.get(DATE)
                                        + " " + cal.get(HOUR_OF_DAY)
                                        + ":" + cal.get(MINUTE)
                                        + ":" + cal.get(SECOND)
                                        + "." + cal.get(MILLISECOND));

                                cal.clear();
                                cal.set(fields[0], fields[1], fields[2],
                                        fields[3], fields[4], fields[5]);
                                cal.set(MILLISECOND, fields[6]);
                                errln(cal.get(YEAR)
                                        + "/" + (cal.get(MONTH) + 1)
                                        + "/" + cal.get(DATE)
                                        + " " + cal.get(HOUR_OF_DAY)
                                        + ":" + cal.get(MINUTE)
                                        + ":" + cal.get(SECOND)
                                        + "." + cal.get(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;
                                    errln((op == 0 ? "add(" : "roll(")
                                            + fieldNames[field] + ", "
                                            + (i < limit ? "+" : "-") + "1) => "
                                            + cal.get(YEAR)
                                            + "/" + (cal.get(MONTH) + 1)
                                            + "/" + cal.get(DATE)
                                            + " " + cal.get(HOUR_OF_DAY)
                                            + ":" + cal.get(MINUTE)
                                            + ":" + cal.get(SECOND)
                                            + "." + cal.get(MILLISECOND)
                                            + " d=" + delta);
                                }
                            }
                        }
                    }
                }
            }
        } finally {
            Locale.setDefault(savedLocale);
        }
    }

    public void Test4174361() {
        GregorianCalendar calendar = new GregorianCalendar(1996, 1, 29);

        calendar.add(MONTH, 10);
        Date date1 = calendar.getTime();
        int d1 = calendar.get(DAY_OF_MONTH);

        calendar = new GregorianCalendar(1996, 1, 29);
        calendar.add(MONTH, 11);
        Date date2 = calendar.getTime();
        int d2 = calendar.get(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(HOUR_OF_DAY);
        cal.setTimeZone(EST);
        int h2 = cal.get(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(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(MONDAY);
        cal.setMinimalDaysInFirstWeek(4);
        DateFormat fmt = new SimpleDateFormat("E dd MMM yyyy  'DOY='D 'WOY='w");
        fmt.setCalendar(cal);

        int[] DATA = {
            2000, JANUARY, 1, 52,
            2001, 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(WEEK_OF_YEAR);
            if (expWOY == actWOY) {
                logln("Ok: " + fmt.format(cal.getTime()));
            } else {
                errln("FAIL: " + fmt.format(cal.getTime())
                        + ", expected WOY=" + expWOY);
                cal.add(DATE, -8);
                for (int j = 0; j < 14; ++j) {
                    cal.add(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
     */
    @SuppressWarnings("deprecation")
    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, JANUARY, 1),
            // 1
            new int[]{MONTH, MARCH},
            new Date(Y, MARCH, 1),
            // 2
            new int[]{DAY_OF_WEEK, WEDNESDAY},
            new Date(Y, JANUARY, 4),
            // 3
            new int[]{DAY_OF_WEEK, THURSDAY,
                DAY_OF_MONTH, 18,},
            new Date(Y, JANUARY, 18),
            // 4
            new int[]{DAY_OF_MONTH, 18,
                DAY_OF_WEEK, THURSDAY,},
            new Date(Y, JANUARY, 18),
            // 5  (WOM -1 is in previous month)
            new int[]{DAY_OF_MONTH, 18,
                WEEK_OF_MONTH, -1,
                DAY_OF_WEEK, THURSDAY,},
            new Date(Y - 1, DECEMBER, 22),
            // 6
            new int[]{DAY_OF_MONTH, 18,
                WEEK_OF_MONTH, 4,
                DAY_OF_WEEK, THURSDAY,},
            new Date(Y, JANUARY, 26),
            // 7  (DIM -1 is in same month)
            new int[]{DAY_OF_MONTH, 18,
                DAY_OF_WEEK_IN_MONTH, -1,
                DAY_OF_WEEK, THURSDAY,},
            new Date(Y, JANUARY, 26),
            // 8
            new int[]{WEEK_OF_YEAR, 9,
                DAY_OF_WEEK, WEDNESDAY,},
            new Date(Y, MARCH, 1),
            // 9
            new int[]{MONTH, OCTOBER,
                DAY_OF_WEEK_IN_MONTH, 1,
                DAY_OF_WEEK, FRIDAY,},
            new Date(Y, OCTOBER, 6),
            // 10
            new int[]{MONTH, OCTOBER,
                WEEK_OF_MONTH, 2,
                DAY_OF_WEEK, FRIDAY,},
            new Date(Y, OCTOBER, 13),
            // 11
            new int[]{MONTH, OCTOBER,
                DAY_OF_MONTH, 15,
                DAY_OF_YEAR, 222,},
            new Date(Y, AUGUST, 10),
            // 12
            new int[]{DAY_OF_WEEK, THURSDAY,
                MONTH, DECEMBER,},
            new Date(Y, 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(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
        @SuppressWarnings("deprecation")
        Object[] DATA = {
            1, new Date(1997 - 1900, JANUARY, 5),
            4, new Date(1997 - 1900, JANUARY, 26),
            8, new Date(1997 - 1900, FEBRUARY, 23),
            -1, new Date(1997 - 1900, JANUARY, 26),
            -4, new Date(1997 - 1900, JANUARY, 5),
            -8, new Date(1996 - 1900, DECEMBER, 8)};
        for (int i = 0; i < DATA.length; i += 2) {
            cal.clear();
            cal.set(DAY_OF_WEEK_IN_MONTH,
                    ((Number) DATA[i]).intValue());
            cal.set(DAY_OF_WEEK, SUNDAY);
            cal.set(MONTH, JANUARY);
            cal.set(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]);
            }
        }
    }

    public void Test4288792() throws Exception {
        TimeZone savedTZ = TimeZone.getDefault();
        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
        GregorianCalendar cal = new GregorianCalendar();
        try {
            for (int i = 1900; i < 2100; i++) {
                for (int j1 = 1; j1 <= 7; j1++) {
                    // Loop for MinimalDaysInFirstWeek: 1..7
                    for (int j = SUNDAY; j <= SATURDAY; j++) {
                        // Loop for FirstDayOfWeek: SUNDAY..SATURDAY
                        cal.clear();
                        cal.setMinimalDaysInFirstWeek(j1);
                        cal.setFirstDayOfWeek(j);
                        cal.set(YEAR, i);
                        int maxWeek = cal.getActualMaximum(WEEK_OF_YEAR);
                        cal.set(WEEK_OF_YEAR, maxWeek);
                        cal.set(DAY_OF_WEEK, j);

                        for (int k = 1; k < 7; k++) {
                            cal.add(DATE, 1);
                            int WOY = cal.get(WEEK_OF_YEAR);
                            if (WOY != maxWeek) {
                                errln(cal.getTime() + ",got=" + WOY
                                        + ",expected=" + maxWeek
                                        + ",min=" + j1 + ",first=" + j);
                            }
                        }

                        cal.add(DATE, 1);
                        int WOY = cal.get(WEEK_OF_YEAR);
                        if (WOY != 1) {
                            errln(cal.getTime() + ",got=" + WOY
                                    + ",expected=1,min=" + j1 + ",first" + j);
                        }
                    }
                }
            }
        } finally {
            TimeZone.setDefault(savedTZ);
        }
    }

    public void Test4328747() throws Exception {
        Calendar c = Calendar.getInstance(Locale.US);
        c.clear();
        c.set(1966, 0, 1); // 1 jan 1966

        // serialize
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream s = new ObjectOutputStream(out);
        s.writeObject(c);
        s.flush();

        // deserialize
        ObjectInputStream t = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
        Calendar result = (Calendar) t.readObject();

        // let recalculate fields with the same UTC time
        result.setTime(result.getTime());
        // Bug gives 1965 11 19
        if ((result.get(YEAR) != 1966) || (result.get(MONTH) != 0)
                || (result.get(DATE) != 1)) {
            errln("deserialized Calendar returned wrong date field(s): "
                    + result.get(YEAR) + "/" + result.get(MONTH) + "/" + result.get(DATE)
                    + ", expected 1966/0/1");
        }
    }

    /**
     * Test whether Calendar can be serialized/deserialized correctly
     * even if invalid/customized TimeZone is used.
     */
    public void Test4413980() {
        TimeZone savedTimeZone = TimeZone.getDefault();
        try {
            boolean pass = true;
            String[] IDs = new String[]{"Undefined", "PST", "US/Pacific",
                "GMT+3:00", "GMT-01:30"};
            for (int i = 0; i < IDs.length; i++) {
                TimeZone tz = TimeZone.getTimeZone(IDs[i]);
                TimeZone.setDefault(tz);

                Calendar c = Calendar.getInstance();

                // serialize
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                ObjectOutputStream s = new ObjectOutputStream(out);
                s.writeObject(c);
                s.flush();

                // deserialize
                ObjectInputStream t = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));

                if (!c.equals(t.readObject())) {
                    pass = false;
                    logln("Calendar instance which uses TimeZone <"
                            + IDs[i] + "> is incorrectly serialized/deserialized.");
                } else {
                    logln("Calendar instance which uses TimeZone <"
                            + IDs[i] + "> is correctly serialized/deserialized.");
                }
            }
            if (!pass) {
                errln("Fail: Calendar serialization/equality bug");
            }
        } catch (IOException | ClassNotFoundException e) {
            errln("Fail: " + e);
            e.printStackTrace();
        } finally {
            TimeZone.setDefault(savedTimeZone);
        }
    }

    /**
     * 4546637: Incorrect WEEK_OF_MONTH after changing First Day Of Week
     */
    public void Test4546637() {
        GregorianCalendar day = new GregorianCalendar(2001, NOVEMBER, 04);
        day.setMinimalDaysInFirstWeek(1);
        int wom = day.get(WEEK_OF_MONTH);

        day.setFirstDayOfWeek(MONDAY);
        if (day.get(WEEK_OF_MONTH) != 1) {
            errln("Fail: 2001/11/4 must be the first week of the month.");
        }
    }

    /**
     * 4623997: GregorianCalendar returns bad WEEK_OF_YEAR
     */
    public void Test4623997() {
        GregorianCalendar cal = new GregorianCalendar(2000, JANUARY, 1);

        int dow = cal.get(DAY_OF_WEEK);

        cal.setFirstDayOfWeek(MONDAY);
        cal.setMinimalDaysInFirstWeek(4);

        if (cal.get(WEEK_OF_YEAR) != 52) {
            errln("Fail: 2000/1/1 must be the 52nd week of the year.");
        }
    }

    /**
     * 4685354: Handling of Calendar fields setting state is broken
     *
     * <p>Need to use SimpleDateFormat to test because a call to
     * get(int) changes internal states of a Calendar.
     */
    public void Test4685354() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesAsciiDigits(locale)
                || !TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        Calendar calendar = Calendar.getInstance(Locale.US);
        DateFormat df = new SimpleDateFormat("yyyy/MM/dd", Locale.US);
        String expected = "1999/12/31";
        Date t;
        String s;

        try {
            calendar.setTime(df.parse(expected));
        } catch (Exception e) {
            throw new RuntimeException("Unexpected parse exception", e);
        }

        t = calendar.getTime();
        calendar.set(DAY_OF_MONTH, 33);
        t = calendar.getTime();
        calendar.set(DAY_OF_MONTH, 0);
        s = df.format(calendar.getTime());
        if (!expected.equals(s)) {
            errln("DAY_OF_MONTH w/o ZONE_OFFSET: expected: " + expected + ", got: " + s);
        }

        // The same thing must work with ZONE_OFFSET set
        try {
            calendar.setTime(df.parse(expected));
        } catch (Exception e) {
            throw new RuntimeException("Unexpected parse exception", e);
        }
        t = calendar.getTime();
        calendar.set(ZONE_OFFSET, calendar.get(ZONE_OFFSET));
        calendar.set(DAY_OF_MONTH, 33);
        t = calendar.getTime();
        calendar.set(DAY_OF_MONTH, 0);
        s = df.format(calendar.getTime());
        if (!expected.equals(s)) {
            errln("DAY_OF_MONTH: expected: " + expected + ", got: " + s);
        }

        expected = "1999/12/24"; // 0th week of 2000
        calendar.clear();
        Date initialDate = null;
        try {
            initialDate = df.parse(expected);
            calendar.setTime(initialDate);
        } catch (Exception e) {
            throw new RuntimeException("Unexpected parse exception", e);
        }
        t = calendar.getTime();
        calendar.set(ZONE_OFFSET, calendar.get(ZONE_OFFSET));
        // jump to the next year
        calendar.set(WEEK_OF_YEAR, 100);
        t = calendar.getTime();
        calendar.set(WEEK_OF_YEAR, 0);
        s = df.format(calendar.getTime());
        if (!expected.equals(s)) {
            errln("WEEK_OF_YEAR: expected: " + expected + ", got: " + s);
        }
        // change the state back
        calendar.clear();
        calendar.setTime(initialDate);
        calendar.set(ZONE_OFFSET, calendar.get(ZONE_OFFSET));
        // jump to next month
        calendar.set(WEEK_OF_MONTH, 7);
        t = calendar.getTime();
        calendar.set(WEEK_OF_MONTH, 0);
        s = df.format(calendar.getTime());
        if (!expected.equals(s)) {
            errln("WEEK_OF_MONTH: expected: " + expected + ", got: " + s);
        }

        // Make sure the time fields work correctly.
        calendar.clear();
        df = new SimpleDateFormat("HH:mm:ss");
        TimeZone tz = TimeZone.getTimeZone("GMT");
        df.setTimeZone(tz);
        calendar.setTimeZone(tz);
        expected = "22:59:59";
        try {
            calendar.setTime(df.parse(expected));
        } catch (Exception e) {
            throw new RuntimeException("Unexpected parse exception", e);
        }
        t = calendar.getTime();
        // time should be 22:59:59.
        calendar.set(MINUTE, 61);
        // time should be 23:01:59.
        t = calendar.getTime();
        calendar.set(MINUTE, -1);
        // time should be back to 22:59:59.
        s = df.format(calendar.getTime());
        if (!expected.equals(s)) {
            errln("MINUTE: expected: " + expected + ", got: " + s);
        }
    }

    /**
     * 4655637: Calendar.set() for DAY_OF_WEEK does not return the right value
     *
     * <p>Need to use SimpleDateFormat to test because a call to
     * get(int) changes internal states of a Calendar.
     */
    public void Test4655637() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            logln("Skipping this test because locale is " + locale);
            return;
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date(1029814211523L));
        cal.set(YEAR, 2001);
        Date t = cal.getTime();
        cal.set(MONTH, JANUARY);
        t = cal.getTime();

        cal.set(DAY_OF_MONTH, 8);
        t = cal.getTime();

        cal.set(DAY_OF_WEEK, MONDAY);
        DateFormat df = new SimpleDateFormat("yyyy/MM/dd", Locale.US);
        String expected = "2001/01/08";
        String s = df.format(cal.getTime());
        if (!expected.equals(s)) {
            errln("expected: " + expected + ", got: " + s);
        }
    }

    /**
     * 4683492: Invalid value for MONTH in GregorianCalendar causes exception in getTime().
     *
     * <p>Need to use SimpleDateFormat to test because a call to
     * get(int) changes internal states of a Calendar.
     *
     * <p>This test case throws ArrayIndexOutOfBoundsException without the fix.
     */
    public void Test4683492() {
        Calendar cal = new GregorianCalendar(2002, 3, 29, 10, 0, 0);
        cal.set(DAY_OF_WEEK, FRIDAY);
        cal.set(DAY_OF_WEEK_IN_MONTH, -1);
        cal.set(MONTH, 12);
        DateFormat df = new SimpleDateFormat("yyyy/MM/dd", Locale.US);
        String expected = "2003/01/31";
        String s = df.format(cal.getTime());
        if (!expected.equals(s)) {
            errln("expected: " + expected + ", got: " + s);
        }
    }

    /**
     * 4080631: Calendar.hashCode is amazingly bad
     */
    public void Test4080631() {
        Calendar cal = Calendar.getInstance();
        int h1 = cal.hashCode();
        cal.add(SECOND, +1);
        int h2 = cal.hashCode();
        Calendar cal2 = (Calendar) cal.clone();
        cal.add(MILLISECOND, +1);
        int h3 = cal.hashCode();
        logln("hash code: h1=" + h1 + ", h2=" + h2 + ", h3=" + h3);
        if (h1 == h2 || h1 == h3 || h2 == h3) {
            errln("hash code is poor: hashCode=" + h1);
        }
        h2 = cal2.hashCode();
        cal.add(MILLISECOND, -1);
        int h4 = cal.hashCode();
        logln("hash code: h2=" + h2 + ", h4=" + h4);
        if (cal.equals(cal2) && h2 != h4) {
            errln("broken hash code: h2=" + h2 + ", h4=" + h4);
        }
        int x = cal.getFirstDayOfWeek() + 3;
        if (x > SATURDAY) {
            x -= 7;
        }
        cal.setFirstDayOfWeek(x);
        int h5 = cal.hashCode();
        logln("hash code: h4=" + h4 + ", h5=" + h5);
        if (h4 == h5) {
            errln("has code is poor with first day of week param: hashCode=" + h4);
        }
    }

    /**
     * 4125161: RFE: GregorianCalendar needs more era names (BCE and CE)
     */
    /*
    public void Test4125161() throws Exception {
        Class gc = GregorianCalendar.class;
        Field f;
        int mod;
        f = gc.getDeclaredField("BCE");
        mod = f.getModifiers();
        if (!Modifier.isStatic(mod) || !Modifier.isFinal(mod)) {
            errln("BCE: wrong modifiers: " + mod);
        }
        f = gc.getDeclaredField("CE");
        mod = f.getModifiers();
        if (!Modifier.isStatic(mod) || !Modifier.isFinal(mod)) {
            errln("CE: wrong modifiers: " + mod);
        }
        if (GregorianCalendar.BCE != GregorianCalendar.BC
            || GregorianCalendar.CE != GregorianCalendar.AD) {
            errln("Wrong BCE and/or CE values");
        }
    }
     */
    /**
     * 4167995: GregorianCalendar.setGregorianChange() not to spec
     */
    public void Test4167995() {
        Koyomi gc = new Koyomi(TimeZone.getTimeZone("GMT"));
        logln("Hybrid: min date");
        gc.setTime(new Date(Long.MIN_VALUE));
        if (!gc.checkDate(292269055, DECEMBER, 2, SUNDAY)
                || !gc.checkFieldValue(ERA, GregorianCalendar.BC)) {
            errln(gc.getMessage());
        }
        logln("Hybrid: max date");
        gc.setTime(new Date(Long.MAX_VALUE));
        if (!gc.checkDate(292278994, AUGUST, 17, SUNDAY)
                || !gc.checkFieldValue(ERA, GregorianCalendar.AD)) {
            errln(gc.getMessage());
        }

        gc.setGregorianChange(new Date(Long.MIN_VALUE));
        logln("Gregorian: min date");
        gc.setTime(new Date(Long.MIN_VALUE));
        if (!gc.checkDate(292275056, MAY, 16, SUNDAY)
                || !gc.checkFieldValue(ERA, GregorianCalendar.BC)) {
            errln(gc.getMessage());
        }
        logln("Gregorian: max date");
        gc.setTime(new Date(Long.MAX_VALUE));
        if (!gc.checkDate(292278994, AUGUST, 17, SUNDAY)
                || !gc.checkFieldValue(ERA, GregorianCalendar.AD)) {
            errln(gc.getMessage());
        }

        gc.setGregorianChange(new Date(Long.MAX_VALUE));
        logln("Julian: min date");
        gc.setTime(new Date(Long.MIN_VALUE));
        if (!gc.checkDate(292269055, DECEMBER, 2, SUNDAY)
                || !gc.checkFieldValue(ERA, GregorianCalendar.BC)) {
            errln(gc.getMessage());
        }
        logln("Julian: max date");
        gc.setTime(new Date(Long.MAX_VALUE));
        if (!gc.checkDate(292272993, JANUARY, 4, SUNDAY)
                || !gc.checkFieldValue(ERA, GregorianCalendar.AD)) {
            errln(gc.getMessage());
        }
    }

    /**
     * 4340146: Calendar.equals modifies state
     */
    public void Test4340146() {
        Koyomi cal = new Koyomi();
        cal.clear();
        cal.set(2003, OCTOBER, 32);
        cal.equals(new Koyomi());
        if (!cal.checkInternalDate(2003, OCTOBER, 32)) {
            errln(cal.getMessage());
        }
        new Koyomi().equals(cal);
        if (!cal.checkInternalDate(2003, OCTOBER, 32)) {
            errln(cal.getMessage());
        }
    }

    /**
     * 4639407: GregorianCalendar doesn't work in non-lenient due to timezone bounds checking
     */
    public void Test4639407() {
        // The following operations in non-lenient mode shouldn't
        // throw IllegalArgumentException.
        Koyomi cal = new Koyomi(TimeZone.getTimeZone("Pacific/Kiritimati"));
        cal.setLenient(false);
        cal.set(2003, OCTOBER, 10);
        cal.getTime();
        cal.setTimeZone(TimeZone.getTimeZone("Pacific/Tongatapu"));
        cal.set(2003, OCTOBER, 10);
        cal.getTime();
    }

    /**
     * 4652815: rolling week-of-year back hundreds of weeks changes year
     */
    public void Test4652815() {
        Koyomi cal = new Koyomi(Locale.US);
        testRoll(cal, 2003, SEPTEMBER, 29);
        testRoll(cal, 2003, DECEMBER, 24);
        testRoll(cal, 1582, DECEMBER, 19);
        testRoll(cal, 1582, DECEMBER, 20);
    }

    private void testRoll(Koyomi cal, int year, int month, int dayOfMonth) {
        cal.clear();
        cal.set(year, month, dayOfMonth);
        cal.getTime(); // normalize fields
        logln("Roll backwards from " + cal.toDateString());
        for (int i = 0; i < 1000; i++) {
            cal.roll(WEEK_OF_YEAR, -i);
            if (!cal.checkFieldValue(YEAR, year)) {
                errln(cal.getMessage());
            }
        }
        logln("Roll forewards from " + cal.toDateString());
        for (int i = 0; i < 1000; i++) {
            cal.roll(WEEK_OF_YEAR, +i);
            if (!cal.checkFieldValue(YEAR, year)) {
                errln(cal.getMessage());
            }
        }
    }

    /**
     * 4652830: GregorianCalendar roll behaves unexpectedly for dates in BC era
     */
    public void Test4652830() {
        Koyomi cal = new Koyomi(Locale.US);
        cal.clear();
        logln("BCE 9-2-28 (leap year) roll DAY_OF_MONTH++ twice");
        cal.set(ERA, GregorianCalendar.BC);
        cal.set(9, FEBRUARY, 28);
        if (cal.getActualMaximum(DAY_OF_YEAR) != 366) {
            errln("    wrong actual max of DAY_OF_YEAR: got "
                    + cal.getActualMaximum(DAY_OF_YEAR) + " expected " + 366);
        }
        cal.roll(DAY_OF_MONTH, +1);
        if (!cal.checkFieldValue(ERA, GregorianCalendar.BC)
                || !cal.checkDate(9, FEBRUARY, 29)) {
            errln(cal.getMessage());
        }
        cal.roll(DAY_OF_MONTH, +1);
        if (!cal.checkFieldValue(ERA, GregorianCalendar.BC)
                || !cal.checkDate(9, FEBRUARY, 1)) {
            errln(cal.getMessage());
        }
    }

    /**
     * 4740554: GregorianCalendar.getActualMaximum is inconsistent with normalization
     */
    public void Test4740554() {
        logln("1999/(Feb+12)/1 should be normalized to 2000/Feb/1 for getActualMaximum");
        Koyomi cal = new Koyomi(Locale.US);
        cal.clear();
        cal.set(1999, FEBRUARY + 12, 1);
        if (!cal.checkActualMaximum(DAY_OF_YEAR, 366)) {
            errln(cal.getMessage());
        }
        if (!cal.checkActualMaximum(DAY_OF_MONTH, 29)) {
            errln(cal.getMessage());
        }
    }

    /**
     * 4936355: GregorianCalendar causes overflow/underflow with time of day calculation
     */
    public void Test4936355() {
        Koyomi cal = new Koyomi(TimeZone.getTimeZone("GMT"));
        cal.clear();
        cal.set(1970, JANUARY, 1);
        checkTimeCalculation(cal, HOUR_OF_DAY, Integer.MAX_VALUE,
                (long) Integer.MAX_VALUE * 60 * 60 * 1000);

        cal.clear();
        cal.set(1970, JANUARY, 1);
        checkTimeCalculation(cal, HOUR, Integer.MAX_VALUE,
                (long) Integer.MAX_VALUE * 60 * 60 * 1000);

        cal.clear();
        cal.set(1970, JANUARY, 1);
        checkTimeCalculation(cal, MINUTE, Integer.MAX_VALUE,
                (long) Integer.MAX_VALUE * 60 * 1000);

        cal.clear();
        // Make sure to use Gregorian dates (before and after the
        // set() call) for testing
        cal.set(250000, JANUARY, 1);
        checkTimeCalculation(cal, HOUR_OF_DAY, Integer.MIN_VALUE,
                (long) Integer.MIN_VALUE * 60 * 60 * 1000);

        cal.clear();
        cal.set(250000, JANUARY, 1);
        checkTimeCalculation(cal, HOUR, Integer.MIN_VALUE,
                (long) Integer.MIN_VALUE * 60 * 60 * 1000);

        cal.clear();
        cal.set(250000, JANUARY, 1);
        checkTimeCalculation(cal, MINUTE, Integer.MIN_VALUE,
                (long) Integer.MIN_VALUE * 60 * 1000);
    }

    private void checkTimeCalculation(Koyomi cal, int field, int value, long expectedDelta) {
        long time = cal.getTimeInMillis();
        cal.set(field, value);
        long time2 = cal.getTimeInMillis();
        if ((time + expectedDelta) != time2) {
            String s = value == Integer.MAX_VALUE ? "Integer.MAX_VALUE" : "Integer.MIN_VALUE";
            errln("set(" + Koyomi.getFieldName(field) + ", " + s + ") failed." + " got " + time2
                    + ", expected " + (time + expectedDelta));
        }
    }

    /**
     * 4722650: Calendar.equals can throw an exception in non-lenient
     * (piggy-back tests for compareTo() which is new in 1.5)
     */
    public void Test4722650() {
        Calendar cal1 = new GregorianCalendar();
        cal1.clear();
        Calendar cal2 = new GregorianCalendar();
        cal2.clear();
        cal2.setLenient(false);

        cal1.set(2003, OCTOBER, 31);
        cal2.set(2003, OCTOBER, 31);
        try {
            if (cal1.equals(cal2)) {
                errln("lenient and non-lenient shouldn't be equal. (2003/10/31)");
            }
            if (cal1.compareTo(cal2) != 0) {
                errln("cal1 and cal2 should represent the same time. (2003/10/31)");
            }
        } catch (IllegalArgumentException e) {
            errln("equals threw IllegalArugumentException with non-lenient");
        }

        cal1.set(2003, OCTOBER, 32);
        cal2.set(2003, OCTOBER, 32);
        try {
            if (cal1.equals(cal2)) {
                errln("lenient and non-lenient shouldn't be equal. (2003/10/32)");
            }
            if (cal1.compareTo(cal2) != 0) {
                errln("cal1 and cal2 should represent the same time. (2003/10/32)");
            }
        } catch (IllegalArgumentException e) {
            errln("equals threw IllegalArugumentException with non-lenient");
        }

        cal1 = Calendar.getInstance(new Locale("th", "TH"));
        cal1.setTimeInMillis(0L);
        cal2 = Calendar.getInstance(Locale.US);
        cal2.setTimeInMillis(0L);
        if (cal1.equals(cal2)) {
            errln("Buddhist.equals(Gregorian) shouldn't be true. (millis=0)");
        }
        if (cal1.compareTo(cal2) != 0) {
            errln("cal1 (Buddhist) and cal2 (Gregorian) should represent the same time. (millis=0)");
        }
    }

    /**
     * 4738710: API: Calendar comparison methods should be improved
     */
    public void Test4738710() {
        Calendar cal0 = new GregorianCalendar(2003, SEPTEMBER, 30);
        Comparable<Calendar> cal1 = new GregorianCalendar(2003, OCTOBER, 1);
        Calendar cal2 = new GregorianCalendar(2003, OCTOBER, 2);
        if (!(cal1.compareTo(cal0) > 0)) {
            errln("!(cal1 > cal0)");
        }
        if (!(cal1.compareTo(cal2) < 0)) {
            errln("!(cal1 < cal2)");
        }
        if (cal1.compareTo(new GregorianCalendar(2003, OCTOBER, 1)) != 0) {
            errln("cal1 != new GregorianCalendar(2003, OCTOBER, 1)");
        }

        if (cal0.after(cal2)) {
            errln("cal0 shouldn't be after cal2");
        }
        if (cal2.before(cal0)) {
            errln("cal2 shouldn't be before cal0");
        }

        if (cal0.after(0)) {
            errln("cal0.after() returned true with an Integer.");
        }
        if (cal0.before(0)) {
            errln("cal0.before() returned true with an Integer.");
        }
        if (cal0.after(null)) {
            errln("cal0.after() returned true with null.");
        }
        if (cal0.before(null)) {
            errln("cal0.before() returned true with null.");
        }
    }

    /**
     * 4633646: Setting WEEK_OF_MONTH to 1 results in incorrect date
     */
    @SuppressWarnings("deprecation")
    public void Test4633646() {
        Koyomi cal = new Koyomi(Locale.US);
        cal.setTime(new Date(2002 - 1900, 1 - 1, 28));
        sub4633646(cal);

        cal.setLenient(false);
        cal.setTime(new Date(2002 - 1900, 1 - 1, 28));
        sub4633646(cal);

        cal = new Koyomi(Locale.US);
        cal.clear();
        cal.set(2002, JANUARY, 28);
        sub4633646(cal);

        cal.clear();
        cal.setLenient(false);
        cal.set(2002, JANUARY, 28);
        sub4633646(cal);
    }

    void sub4633646(Koyomi cal) {
        cal.getTime();
        cal.set(WEEK_OF_MONTH, 1);
        if (cal.isLenient()) {
            if (!cal.checkDate(2001, DECEMBER, 31)) {
                errln(cal.getMessage());
            }
            if (!cal.checkFieldValue(WEEK_OF_MONTH, 6)) {
                errln(cal.getMessage());
            }
        } else {
            try {
                Date d = cal.getTime();
                errln("didn't throw IllegalArgumentException in non-lenient");
            } catch (IllegalArgumentException e) {
            }
        }
    }

    /**
     * 4846659: Calendar: Both set() and roll() don't work for AM_PM time field
     * (Partially fixed only roll as of 1.5)
     */
    public void Test4846659() {
        Koyomi cal = new Koyomi();
        cal.clear();
        cal.set(2003, OCTOBER, 31, 10, 30, 30);
        cal.getTime();
        // Test roll()
        cal.roll(AM_PM, +1); // should turn to PM
        if (!cal.checkFieldValue(HOUR_OF_DAY, 10 + 12)) {
            errln("roll: AM_PM didn't change to PM");
        }

        cal.clear();
        cal.set(2003, OCTOBER, 31, 10, 30, 30);
        cal.getTime();
        // Test set()
        cal.set(AM_PM, PM); // should turn to PM
        if (!cal.checkFieldValue(HOUR_OF_DAY, 10 + 12)) {
            errln("set: AM_PM didn't change to PM");
        }

        cal.clear();
        cal.set(2003, OCTOBER, 31, 10, 30, 30);
        cal.getTime();
        cal.set(AM_PM, PM);
        cal.set(HOUR, 9);
        if (!cal.checkFieldValue(HOUR_OF_DAY, 9 + 12)) {
            errln("set: both AM_PM and HOUT didn't change to PM");
        }
    }

    /**
     * 4822110: GregorianCalendar.get() returns an incorrect date after setFirstDayOfWeek()
     */
    public void Test4822110() {
        Koyomi cal = new Koyomi(Locale.US);
        //    June 2003
        //  S  M Tu  W Th  F  S
        //  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
        cal.clear();
        // 6/1 to 6/7 should be the 1st week of June.
        cal.set(2003, JUNE, 2);
        cal.getTime();                  // Let cal calculate time.
        cal.setFirstDayOfWeek(MONDAY);
        // Now 6/2 to 6/8 should be the 2nd week of June. Sunday of
        // that week is 6/8.
        logln("1: " + cal.get(WEEK_OF_MONTH) + ", " + cal.get(DAY_OF_MONTH));
        cal.set(DAY_OF_WEEK, SUNDAY);
        logln("1st Sunday of June 2003 with FirstDayOfWeek=MONDAY");
        if (!cal.checkDate(2003, JUNE, 8)) {
            errln(cal.getMessage());
        }
    }

    /**
     * 4973919: Inconsistent GregorianCalendar hashCode before and after serialization
     */
    public void Test4966499() throws Exception {
        GregorianCalendar date1 = new GregorianCalendar(2004, JANUARY, 7);

        // Serialize date1
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(date1);

        byte[] buffer = baos.toByteArray();

        // Deserialize it
        ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
        ObjectInputStream ois = new ObjectInputStream(bais);
        GregorianCalendar date2 = (GregorianCalendar) ois.readObject();

        if (!date1.equals(date2)) {
            errln("date1.equals(date2) != true");
        }
        if (date1.hashCode() != date2.hashCode()) {
            errln("inconsistent hashCode() value (before=0x"
                    + Integer.toHexString(date1.hashCode())
                    + ", after=0x" + Integer.toHexString(date2.hashCode()) + ")");
        }
    }

    /**
     * 4980088: GregorianCalendar.getActualMaximum doesn't throw exception
     */
    public void Test4980088() {
        GregorianCalendar cal = new GregorianCalendar();
        try {
            int x = cal.getMaximum(100);
            errln("getMaximum(100) didn't throw an exception.");
        } catch (IndexOutOfBoundsException e) {
            logln("getMaximum: " + e.getClass().getName() + ": " + e.getMessage());
        }

        try {
            int x = cal.getLeastMaximum(100);
            errln("getLeastMaximum(100) didn't throw an exception.");
        } catch (IndexOutOfBoundsException e) {
            logln("getLeastMaximum: " + e.getClass().getName() + ": " + e.getMessage());
        }

        try {
            int x = cal.getActualMaximum(100);
            errln("getActualMaximum(100) didn't throw an exception.");
        } catch (IndexOutOfBoundsException e) {
            logln("getActualMaximum: " + e.getClass().getName() + ": " + e.getMessage());
        }

        try {
            int x = cal.getMinimum(100);
            errln("getMinimum(100) didn't throw an exception.");
        } catch (IndexOutOfBoundsException e) {
            logln("getMinimum: " + e.getClass().getName() + ": " + e.getMessage());
        }

        try {
            int x = cal.getGreatestMinimum(100);
            errln("getGreatestMinimum(100) didn't throw an exception.");
        } catch (IndexOutOfBoundsException e) {
            logln("getGreatestMinimum: " + e.getClass().getName() + ": " + e.getMessage());
        }

        try {
            int x = cal.getActualMinimum(100);
            errln("getActualMinimum(100) didn't throw an exception.");
        } catch (IndexOutOfBoundsException e) {
            logln("getActualMinimum: " + e.getClass().getName() + ": " + e.getMessage());
        }
    }

    /**
     * 4965624: GregorianCalendar.isLeapYear(1000) returns incorrect value
     */
    public void Test4965624() {
        // 5013094: This test case needs to use "GMT" to specify
        // Gregorian cutover dates.
        TimeZone savedZone = TimeZone.getDefault();
        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
        try {
            Map<Date, Boolean> data = new HashMap<>();
            data.put(getGregorianDate(999, OCTOBER, 1), Boolean.FALSE);
            data.put(getGregorianDate(1000, JANUARY, 1), Boolean.FALSE);
            data.put(getGregorianDate(1000, FEBRUARY, 1), Boolean.FALSE);
            data.put(getGregorianDate(1000, FEBRUARY, 28), Boolean.FALSE);
            data.put(getGregorianDate(1000, MARCH, 1), Boolean.TRUE);
            data.put(getGregorianDate(1001, JANUARY, 1), Boolean.TRUE);
            data.put(getGregorianDate(1001, JANUARY, 6), Boolean.TRUE);
            data.put(getGregorianDate(1001, MARCH, 1), Boolean.TRUE);

            data.keySet().forEach(d -> {
                boolean expected = data.get(d);
                GregorianCalendar cal = new GregorianCalendar();
                cal.setGregorianChange(d);
                if (cal.isLeapYear(1000) != expected) {
                    errln("isLeapYear(1000) returned " + cal.isLeapYear(1000)
                            + " with cutover date (Julian) " + d);
                }
            });
        } finally {
            TimeZone.setDefault(savedZone);
        }
    }

    // Note that we can't use Date to produce Gregorian calendar dates
    // before the default cutover date.
    static Date getGregorianDate(int year, int month, int dayOfMonth) {
        GregorianCalendar g = new GregorianCalendar();
        // Make g a pure Gregorian calendar
        g.setGregorianChange(new Date(Long.MIN_VALUE));
        g.clear();
        g.set(year, month, dayOfMonth);
        return g.getTime();
    }

    /**
     * 5006864: Define the minimum value of DAY_OF_WEEK_IN_MONTH as 1
     */
    public void Test5006864() {
        GregorianCalendar cal = new GregorianCalendar();
        int min = cal.getMinimum(DAY_OF_WEEK_IN_MONTH);
        if (min != 1) {
            errln("GregorianCalendar.getMinimum(DAY_OF_WEEK_IN_MONTH) returned "
                    + min + ", expected 1.");
        }
        min = cal.getGreatestMinimum(DAY_OF_WEEK_IN_MONTH);
        if (min != 1) {
            errln("GregorianCalendar.getGreatestMinimum(DAY_OF_WEEK_IN_MONTH) returned "
                    + min + ", expected 1.");
        }
    }
}