/*

 * Copyright (c) 2003, 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 4359204 4928615 4743587 4956232 6459836 6549953

 * @library /java/text/testlib

 * @build Koyomi

 * @run main GregorianCutoverTest

 * @summary Unit tests related to the Gregorian cutover support.

 */

import java.util.Date;

import java.util.Locale;

import java.util.TimeZone;

import static java.util.GregorianCalendar.*;

public class GregorianCutoverTest extends IntlTest {

    public static void main(String[] args) throws Exception {

        TimeZone tz = TimeZone.getDefault();

        Locale lc = Locale.getDefault();

        try {

            TimeZone.setDefault(TimeZone.getTimeZone("GMT"));

            Locale.setDefault(Locale.US);

            new GregorianCutoverTest().run(args);

        } finally {

            TimeZone.setDefault(tz);

            Locale.setDefault(lc);

        }

    }

    /**

     * 4359204: GregorianCalendar.get(cal.DAY_OF_YEAR) is inconsistent for year 1582

     */

    public void Test4359204() {

        Koyomi cal = new Koyomi();

        cal.set(1582, JANUARY, 1);

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        cal.set(1582, OCTOBER, 1);

        checkContinuity(cal, WEEK_OF_MONTH);

        // JCK tests the cutover date 1970-1-1 (Epoch)

        cal.setGregorianChange(new Date(0));

        cal.set(1969, JANUARY, 1);

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        cal.set(1969, DECEMBER, 1);

        checkContinuity(cal, WEEK_OF_MONTH);

        cal.set(1970, JANUARY, 1);

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        // Use large date (year >= 50000)

        @SuppressWarnings("deprecation")

        Date d = new Date(50000 - 1900, JANUARY, 20);

        cal.setGregorianChange(d);

        cal.set(49998, JANUARY, 1);

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        cal.set(49999, JANUARY, 1);

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        cal.set(50000, JANUARY, 20);

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        // Handling of "overlapping" dates may still be incorrect as

        // of 1.5. Also, there's no way to disambiguate "overlapping"

        // dates.

        // millis=-112033929600000: date=-1581-10-15T00:00:00.000Z

        cal.setGregorianChange(new Date(-112033929600000L));

        cal.set(ERA, AD);

        cal.set(-1581, JANUARY, 1);

        // The year should have 379 days.

        checkContinuity(cal, DAY_OF_YEAR);

        checkContinuity(cal, WEEK_OF_YEAR);

        logln("Default cutover");

        cal = new Koyomi();

        cal.set(1582, OCTOBER, 1);

        logln("  roll --DAY_OF_MONTH from 1582/10/01");

        cal.roll(DAY_OF_MONTH, -1);

        if (!cal.checkDate(1582, OCTOBER, 31)) {

            errln(cal.getMessage());

        }

        logln("  roll DAY_OF_MONTH+10 from 1582/10/31");

        cal.roll(DAY_OF_MONTH, +10);

        if (!cal.checkDate(1582, OCTOBER, 20)) {

            errln(cal.getMessage());

        }

        logln("  roll DAY_OF_MONTH-10 from 1582/10/20");

        cal.roll(DAY_OF_MONTH, -10);

        if (!cal.checkDate(1582, OCTOBER, 31)) {

            errln(cal.getMessage());

        }

        logln("  roll back one day further");

        cal.roll(DAY_OF_MONTH, +1);

        if (!cal.checkDate(1582, OCTOBER, 1)) {

            errln(cal.getMessage());

        }

        // should handle the gap between 1969/12/22 (Julian) to 1970/1/5 (Gregorian)

        logln("Cutover date is 1970/1/5");

        @SuppressWarnings("deprecation")

        Date d1 = new Date(1970 - 1900, JANUARY, 5);

        cal.setGregorianChange(d1);

        cal.set(ERA, AD);

        cal.set(YEAR, 1970);

        logln("  Set DAY_OF_YEAR to the 28th day of 1970");

        cal.set(DAY_OF_YEAR, 28);

        if (!cal.checkDate(1970, FEBRUARY, 1)) {

            errln(cal.getMessage());

        }

        if (!cal.checkFieldValue(WEEK_OF_YEAR, 5)) {

            errln(cal.getMessage());

        }

        logln("  1969/12/22 should be the 356th day of the year.");

        cal.set(1969, DECEMBER, 22);

        if (!cal.checkFieldValue(DAY_OF_YEAR, 356)) {

            errln(cal.getMessage());

        }

        logln("  Set DAY_OF_YEAR to autual maximum.");

        int actualMaxDayOfYear = cal.getActualMaximum(DAY_OF_YEAR);

        if (actualMaxDayOfYear != 356) {

            errln("actual maximum of DAY_OF_YEAR: got " + actualMaxDayOfYear + ", expected 356");

        }

        cal.set(DAY_OF_YEAR, actualMaxDayOfYear);

        if (!cal.checkDate(1969, DECEMBER, 22)) {

            errln(cal.getMessage());

        }

        cal.set(1969, DECEMBER, 22);

        cal.roll(DAY_OF_YEAR, +1);

        logln("  Set to 1969/12/22 and roll DAY_OF_YEAR++");

        if (!cal.checkDate(1969, JANUARY, 1)) {

            errln(cal.getMessage());

        }

        logln("  1970/1/5 should be the first day of the year.");

        cal.set(1970, JANUARY, 5);

        if (!cal.checkFieldValue(DAY_OF_YEAR, 1)) {

            errln(cal.getMessage());

        }

        logln("  roll --DAY_OF_MONTH from 1970/1/5");

        cal.roll(DAY_OF_MONTH, -1);

        if (!cal.checkDate(1970, JANUARY, 31)) {

            errln(cal.getMessage());

        }

        logln("  roll back one day of month");

        cal.roll(DAY_OF_MONTH, +1);

        if (!cal.checkDate(1970, JANUARY, 5)) {

            errln(cal.getMessage());

        }

        // Test "missing" dates in non-lenient.

        cal = new Koyomi(); // new instance for the default cutover

        cal.setLenient(false);

        try {

            // the next day of 1582/10/4 (Julian) is 1582/10/15 (Gregorian)

            logln("1582/10/10 doesn't exit with the default cutover.");

            cal.set(1582, OCTOBER, 10);

            cal.getTime();

            errln("    Didn't throw IllegalArgumentException in non-lenient.");

        } catch (IllegalArgumentException e) {

        }

    }

    private void checkContinuity(Koyomi cal, int field) {

        cal.getTime();

        logln(Koyomi.getFieldName(field) + " starting on " + cal.toDateString());

        int max = cal.getActualMaximum(field);

        for (int i = 1; i <= max; i++) {

            logln(i + "    " + cal.toDateString());

            if (!cal.checkFieldValue(field, i)) {

                errln("    " + cal.toDateString() + ":\t" + cal.getMessage());

            }

            cal.add(field, +1);

        }

    }

    /**

     * 4928615: GregorianCalendar returns wrong dates after setGregorianChange

     */

    public void Test4928615() {

        Koyomi cal = new Koyomi();

        logln("Today is 2003/10/1 Gregorian.");

        @SuppressWarnings("deprecation")

        Date x = new Date(2003 - 1900, 10 - 1, 1);

        cal.setTime(x);

        logln("  Changing the cutover date to yesterday...");

        cal.setGregorianChange(new Date(x.getTime() - (24 * 3600 * 1000)));

        if (!cal.checkDate(2003, OCTOBER, 1)) {

            errln("    " + cal.getMessage());

        }

        logln("  Changing the cutover date to tomorrow...");

        cal.setGregorianChange(new Date(x.getTime() + (24 * 3600 * 1000)));

        if (!cal.checkDate(2003, SEPTEMBER, 18)) {

            errln("    " + cal.getMessage());

        }

    }

    /**

     * 4743587: GregorianCalendar.getLeastMaximum() returns wrong values

     */

    public void Test4743587() {

        Koyomi cal = new Koyomi();

        Koyomi cal2 = (Koyomi) cal.clone();

        logln("getLeastMaximum should handle cutover year.\n"

                + "  default cutover date");

        if (!cal.checkLeastMaximum(DAY_OF_YEAR, 365 - 10)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkLeastMaximum(WEEK_OF_YEAR, 52 - ((10 + 6) / 7))) {

            errln("    " + cal.getMessage());

        }

        // Corrected for 4956232

        if (!cal.checkLeastMaximum(DAY_OF_MONTH, 28)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkLeastMaximum(WEEK_OF_MONTH, 3)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkLeastMaximum(DAY_OF_WEEK_IN_MONTH, 3)) {

            errln("    " + cal.getMessage());

        }

        // make sure that getLeastMaximum calls didn't affect the date

        if (!cal.equals(cal2)) {

            errln("    getLeastMaximum calls modified the object.");

        }

        if (!cal.checkGreatestMinimum(DAY_OF_MONTH, 1)) {

            errln("    " + cal.getMessage());

        }

        logln("  changing the date to 1582/10/20 for actual min/max tests");

        cal.set(1582, OCTOBER, 20);

        if (!cal.checkActualMinimum(DAY_OF_MONTH, 1)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkActualMaximum(DAY_OF_MONTH, 31)) {

            errln("    " + cal.getMessage());

        }

        cal = new Koyomi();

        logln("Change the cutover date to 1970/1/5.");

        @SuppressWarnings("deprecation")

        Date d = new Date(1970 - 1900, 0, 5);

        cal.setGregorianChange(d);

        if (!cal.checkLeastMaximum(DAY_OF_YEAR, 356)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkLeastMaximum(DAY_OF_MONTH, 22)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkGreatestMinimum(DAY_OF_MONTH, 5)) {

            errln("    " + cal.getMessage());

        }

        cal.set(1970, JANUARY, 10);

        if (!cal.checkActualMinimum(DAY_OF_MONTH, 5)) {

            errln("    " + cal.getMessage());

        }

        if (!cal.checkActualMaximum(DAY_OF_MONTH, 31)) {

            errln("    " + cal.getMessage());

        }

    }

    /**

     * 6459836: (cal) GregorianCalendar set method provides wrong result

     */

    public void Test6459836() {

        int hour = 13865672;

        Koyomi gc1 = new Koyomi();

        gc1.clear();

        gc1.set(1, JANUARY, 1, 0, 0, 0);

        gc1.set(HOUR_OF_DAY, hour);

        if (!gc1.checkDate(1582, OCTOBER, 4)) {

            errln("test case 1: " + gc1.getMessage());

        }

        gc1.clear();

        gc1.set(1, JANUARY, 1, 0, 0, 0);

        gc1.set(HOUR_OF_DAY, hour + 24);

        if (!gc1.checkDate(1582, OCTOBER, 15)) {

            errln("test case 2: " + gc1.getMessage());

        }

    }

    /**

     * 6549953 (cal) WEEK_OF_YEAR and DAY_OF_YEAR calculation problems around Gregorian cutover

     */

    public void Test6549953() {

        Koyomi cal = new Koyomi();

        cal.set(YEAR, 1582);

        cal.set(WEEK_OF_YEAR, 42);

        cal.set(DAY_OF_WEEK, FRIDAY);

        cal.checkFieldValue(WEEK_OF_YEAR, 42);

        cal.checkFieldValue(DAY_OF_WEEK, FRIDAY);

        if (!cal.checkDate(1582, OCTOBER, 29)) {

            errln(cal.getMessage());

        }

        cal.clear();

        cal.set(1582, OCTOBER, 1);

        cal.set(DAY_OF_YEAR, 292);

        if (!cal.checkDate(1582, OCTOBER, 29)) {

            errln(cal.getMessage());

        }

    }

}