/*
 * Copyright (c) 1997, 2023, 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 4064654 4374886 4984320 4984574 4944795 8210142
 * @summary test for Calendar
 * @library /java/text/testlib
 * @modules java.base/java.util:+open
 * @run junit CalendarTest
 * @key randomness
 */

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.SimpleTimeZone;
import java.util.TimeZone;

import static java.util.Calendar.*;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.fail;

public class CalendarTest {

    static final int ONE_DAY = 24 * 60 * 60 * 1000;
    static final int EPOCH_JULIAN = 2440588;

    /**
     * Test the behavior of the GregorianCalendar around the changeover.
     */
    @Test
    public void TestGregorianChangeover() {
        TimeZone savedZone = TimeZone.getDefault();
        /*
          Changeover -7 days: 1582/9/28 dow=6
          Changeover -6 days: 1582/9/29 dow=7
          Changeover -5 days: 1582/9/30 dow=1
          Changeover -4 days: 1582/10/1 dow=2
          Changeover -3 days: 1582/10/2 dow=3
          Changeover -2 days: 1582/10/3 dow=4
          Changeover -1 days: 1582/10/4 dow=5
          Changeover +0 days: 1582/10/15 dow=6
          Changeover +1 days: 1582/10/16 dow=7
          Changeover +2 days: 1582/10/17 dow=1
          Changeover +3 days: 1582/10/18 dow=2
          Changeover +4 days: 1582/10/19 dow=3
          Changeover +5 days: 1582/10/20 dow=4
          Changeover +6 days: 1582/10/21 dow=5
          Changeover +7 days: 1582/10/22 dow=6
          */
        int[] MON = {  9,  9,  9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };
        int[] DOM = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };
        int[] DOW = {  6,  7,  1, 2, 3, 4, 5,  6,  7,  1,  2,  3,  4,  5,  6 };
        //                                     ^ <-Changeover Fri Oct 15 1582
        try {
            TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
            @SuppressWarnings("deprecation")
            Date co = new Date(1582 - 1900, OCTOBER, 15);
            GregorianCalendar cal = new GregorianCalendar();
            int j = 0;
            for (int i = -7; i <= 7; ++i, ++j) {
                Date d = new Date(co.getTime() + i * ONE_DAY);
                cal.setTime(d);
                int y = cal.get(YEAR);
                int mon = cal.get(MONTH) + 1 - JANUARY;
                int dom = cal.get(DATE);
                int dow = cal.get(DAY_OF_WEEK);

                System.out.println("Changeover " + (i >= 0 ? "+" : "") + i
                        + " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);
                if (y != 1582 || mon != MON[j] || dom != DOM[j] || dow != DOW[j]) {
                    fail(" Fail: Above line is wrong");
                }
            }
        } finally {
            TimeZone.setDefault(savedZone);
        }
    }

    /**
     * Test the mapping between millis and fields.  For the purposes
     * of this test, we don't care about timezones and week data
     * (first day of week, minimal days in first week).
     */
    @SuppressWarnings("deprecation")
    @Test
    public void TestMapping() {
        TimeZone saveZone = TimeZone.getDefault();
        int[] DATA = {
            // Julian#   Year      Month    DOM   JULIAN:Year  Month,   DOM
            2440588,     1970,    JANUARY,   1,    1969,     DECEMBER,  19,
            2415080,     1900,      MARCH,   1,    1900,     FEBRUARY,  17,
            2451604,     2000,   FEBRUARY,  29,    2000,     FEBRUARY,  16,
            2452269,     2001,   DECEMBER,  25,    2001,     DECEMBER,  12,
            2416526,     1904,   FEBRUARY,  15,    1904,     FEBRUARY,   2,
            2416656,     1904,       JUNE,  24,    1904,         JUNE,  11,
            1721426,        1,    JANUARY,   1,       1,      JANUARY,   3,
            2000000,      763,  SEPTEMBER,  18,     763,    SEPTEMBER,  14,
            4000000,     6239,       JULY,  12,    6239,          MAY,  28,
            8000000,    17191,   FEBRUARY,  26,   17190,      OCTOBER,  22,
           10000000,    22666,   DECEMBER,  20,   22666,         JULY,   5};

        try {
            TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
            Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);
            Date PURE_JULIAN = new Date(Long.MAX_VALUE);
            GregorianCalendar cal = new GregorianCalendar();
            for (int i = 0; i < DATA.length; i += 7) {
                int julian = DATA[i];
                int year = DATA[i + 1];
                int month = DATA[i + 2];
                int dom = DATA[i + 3];
                int year2, month2, dom2;
                long millis = ((long) julian - EPOCH_JULIAN) * ONE_DAY;
                String s;

                // Test Gregorian computation
                cal.setGregorianChange(PURE_GREGORIAN);
                cal.clear();
                cal.set(year, month, dom);
                long calMillis = cal.getTime().getTime();
                long delta = calMillis - millis;
                cal.setTime(new Date(millis));
                year2 = cal.get(YEAR);
                month2 = cal.get(MONTH);
                dom2 = cal.get(DAY_OF_MONTH);
                s = "G " + year + "-" + (month + 1 - JANUARY) + "-" + dom
                        + " => " + calMillis
                        + " (" + ((float) delta / ONE_DAY) + " day delta) => "
                        + year2 + "-" + (month2 + 1 - JANUARY) + "-" + dom2;
                if (delta != 0 || year != year2 || month != month2
                        || dom != dom2) {
                    fail(s + " FAIL");
                } else {
                    System.out.println(s);
                }

                // Test Julian computation
                year = DATA[i + 4];
                month = DATA[i + 5];
                dom = DATA[i + 6];
                cal.setGregorianChange(PURE_JULIAN);
                cal.clear();
                cal.set(year, month, dom);
                calMillis = cal.getTime().getTime();
                delta = calMillis - millis;
                cal.setTime(new Date(millis));
                year2 = cal.get(YEAR);
                month2 = cal.get(MONTH);
                dom2 = cal.get(DAY_OF_MONTH);
                s = "J " + year + "-" + (month + 1 - JANUARY) + "-" + dom
                        + " => " + calMillis
                        + " (" + ((float) delta / ONE_DAY) + " day delta) => "
                        + year2 + "-" + (month2 + 1 - JANUARY) + "-" + dom2;
                if (delta != 0 || year != year2 || month != month2
                        || dom != dom2) {
                    fail(s + " FAIL");
                } else {
                    System.out.println(s);
                }
            }

            cal.setGregorianChange(new Date(1582 - 1900, OCTOBER, 15));
            auxMapping(cal, 1582, OCTOBER, 4);
            auxMapping(cal, 1582, OCTOBER, 15);
            auxMapping(cal, 1582, OCTOBER, 16);
            for (int y = 800; y < 3000; y += 1 + 100 * Math.random()) {
                for (int m = JANUARY; m <= DECEMBER; ++m) {
                    auxMapping(cal, y, m, 15);
                }
            }
        } finally {
            TimeZone.setDefault(saveZone);
        }
    }
    private void auxMapping(Calendar cal, int y, int m, int d) {
        cal.clear();
        cal.set(y, m, d);
        long millis = cal.getTime().getTime();
        cal.setTime(new Date(millis));
        int year2 = cal.get(YEAR);
        int month2 = cal.get(MONTH);
        int dom2 = cal.get(DAY_OF_MONTH);
        if (y != year2 || m != month2 || dom2 != d) {
            fail("Round-trip failure: " + y + "-" + (m + 1) + "-" + d + " =>ms=> "
                    + year2 + "-" + (month2 + 1) + "-" + dom2);
        }
    }

    @SuppressWarnings("deprecation")
    @Test
    public void TestGenericAPI() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            System.out.println("Skipping this test because locale is " + locale);
            return;
        }

        String str;
        Date when = new Date(90, APRIL, 15);

        String tzid = "TestZone";
        int tzoffset = 123400;

        SimpleTimeZone zone = new SimpleTimeZone(tzoffset, tzid);
        Calendar cal = Calendar.getInstance((SimpleTimeZone) zone.clone());

        if (!zone.equals(cal.getTimeZone())) {
            fail("FAIL: Calendar.getTimeZone failed");
        }

        Calendar cal2 = Calendar.getInstance(cal.getTimeZone());

        cal.setTime(when);
        cal2.setTime(when);

        if (!(cal.equals(cal2))) {
            fail("FAIL: Calendar.operator== failed");
        }
        // if ((*cal != *cal2))  errln("FAIL: Calendar.operator!= failed");
        if (!cal.equals(cal2)
                || cal.before(cal2)
                || cal.after(cal2)) {
            fail("FAIL: equals/before/after failed");
        }

        cal2.setTime(new Date(when.getTime() + 1000));
        if (cal.equals(cal2)
                || cal2.before(cal)
                || cal.after(cal2)) {
            fail("FAIL: equals/before/after failed");
        }

        cal.roll(SECOND, true);
        if (!cal.equals(cal2)
                || cal.before(cal2)
                || cal.after(cal2)) {
            fail("FAIL: equals/before/after failed");
        }

        // Roll back to January
        cal.roll(MONTH, 1 + DECEMBER - cal.get(MONTH));
        if (cal.equals(cal2)
                || cal2.before(cal)
                || cal.after(cal2)) {
            fail("FAIL: equals/before/after failed");
        }

        // C++ only
        /* TimeZone z = cal.orphanTimeZone();
        if (z.getID(str) != tzid ||
        z.getRawOffset() != tzoffset)
        fail("FAIL: orphanTimeZone failed");
        */
        for (int i = 0; i < 2; ++i) {
            boolean lenient = (i > 0);
            cal.setLenient(lenient);
            if (lenient != cal.isLenient()) {
                fail("FAIL: setLenient/isLenient failed");
            }
            // Later: Check for lenient behavior
        }

        int i;
        for (i = SUNDAY; i <= SATURDAY; ++i) {
            cal.setFirstDayOfWeek(i);
            if (cal.getFirstDayOfWeek() != i) {
                fail("FAIL: set/getFirstDayOfWeek failed");
            }
        }

        for (i = 0; i <= 7; ++i) {
            cal.setMinimalDaysInFirstWeek(i);
            if (cal.getMinimalDaysInFirstWeek() != i) {
                fail("FAIL: set/getFirstDayOfWeek failed");
            }
        }

        for (i = 0; i < FIELD_COUNT; ++i) {
            if (cal.getMinimum(i) != cal.getGreatestMinimum(i)) {
                fail("FAIL: getMinimum doesn't match getGreatestMinimum for field " + i);
            }
            if (cal.getLeastMaximum(i) > cal.getMaximum(i)) {
                fail("FAIL: getLeastMaximum larger than getMaximum for field " + i);
            }
            if (cal.getMinimum(i) >= cal.getMaximum(i)) {
                fail("FAIL: getMinimum not less than getMaximum for field " + i);
            }
        }

        cal.setTimeZone(TimeZone.getDefault());
        cal.clear();
        cal.set(1984, 5, 24);
        if (cal.getTime().getTime() != new Date(84, 5, 24).getTime()) {
            fail("FAIL: Calendar.set(3 args) failed");
            System.out.println(" Got: " + cal.getTime() + "  Expected: " + new Date(84, 5, 24));
        }

        cal.clear();
        cal.set(1985, 3, 2, 11, 49);
        if (cal.getTime().getTime() != new Date(85, 3, 2, 11, 49).getTime()) {
            fail("FAIL: Calendar.set(5 args) failed");
            System.out.println(" Got: " + cal.getTime() + "  Expected: " + new Date(85, 3, 2, 11, 49));
        }

        cal.clear();
        cal.set(1995, 9, 12, 1, 39, 55);
        if (cal.getTime().getTime() != new Date(95, 9, 12, 1, 39, 55).getTime()) {
            fail("FAIL: Calendar.set(6 args) failed");
            System.out.println(" Got: " + cal.getTime() + "  Expected: " + new Date(95, 9, 12, 1, 39, 55));
        }

        cal.getTime();
        for (i = 0; i < FIELD_COUNT; ++i) {
            switch (i) {
                case YEAR:
                case MONTH:
                case DATE:
                case HOUR_OF_DAY:
                case MINUTE:
                case SECOND:
                    if (!cal.isSet(i)) {
                        fail("FAIL: !Calendar.isSet test failed: " + calendarFieldNames[i]);
                    }
                    break;
                default:
                    if (cal.isSet(i)) {
                        fail("FAIL: Calendar.isSet test failed: " + calendarFieldNames[i]);
                    }
            }
            cal.clear(i);
            if (cal.isSet(i)) {
                fail("FAIL: Calendar.clear/isSet failed");
            }
        }

        // delete cal;
        // delete cal2;
        Locale[] loc = Calendar.getAvailableLocales();
        long count = loc.length;
        if (count < 1 || loc == null) {
            fail("FAIL: getAvailableLocales failed");
        } else {
            for (i = 0; i < count; ++i) {
                cal = Calendar.getInstance(loc[i]);
                // delete cal;
            }
        }

        cal = Calendar.getInstance(TimeZone.getDefault(), Locale.ENGLISH);
        // delete cal;

        cal = Calendar.getInstance(zone, Locale.ENGLISH);
        // delete cal;

        GregorianCalendar gc = new GregorianCalendar(zone);
        // delete gc;

        gc = new GregorianCalendar(Locale.ENGLISH);
        // delete gc;

        gc = new GregorianCalendar(Locale.ENGLISH);
        // delete gc;

        gc = new GregorianCalendar(zone, Locale.ENGLISH);
        // delete gc;

        gc = new GregorianCalendar(zone);
        // delete gc;

        gc = new GregorianCalendar(1998, 10, 14, 21, 43);
        if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43).getTime()) {
            fail("FAIL: new GregorianCalendar(ymdhm) failed");
        }
        // delete gc;

        gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55);
        if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43, 55).getTime()) {
            fail("FAIL: new GregorianCalendar(ymdhms) failed");
        }

        // C++ only:
        // GregorianCalendar gc2 = new GregorianCalendar(Locale.ENGLISH);
        // gc2 = gc;
        // if (gc2 != gc || !(gc2 == gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");
        // delete gc;
        // delete z;
    }

    // Verify Roger Webster's bug
    @Test
    public void TestRog() {
        GregorianCalendar gc = new GregorianCalendar();

        int year = 1997, month = APRIL, date = 1;
        gc.set(year, month, date); // April 1, 1997

        gc.set(HOUR_OF_DAY, 23);
        gc.set(MINUTE, 0);
        gc.set(SECOND, 0);
        gc.set(MILLISECOND, 0);

        for (int i = 0; i < 9; i++, gc.add(DATE, 1)) {
            if (gc.get(YEAR) != year
                    || gc.get(MONTH) != month
                    || gc.get(DATE) != (date + i)) {
                fail("FAIL: Date " + gc.getTime() + " wrong");
            }
        }
    }

    // Verify DAY_OF_WEEK
    @Test
    public void TestDOW943() {
        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);
        if (dow < min || dow > max) {
            fail("FAIL: Day of week " + dow + " out of range");
        }
        if (dow != SUNDAY) {
            fail("FAIL2: Day of week should be SUNDAY; is " + dow + ": " + cal.getTime());
        }
        if (min != SUNDAY || max != SATURDAY) {
            fail("FAIL: Min/max bad");
        }
    }

    // Verify that the clone method produces distinct objects with no
    // unintentionally shared fields.
    @Test
    public void TestClonesUnique908() {
        Calendar c = Calendar.getInstance();
        Calendar d = (Calendar) c.clone();
        c.set(MILLISECOND, 123);
        d.set(MILLISECOND, 456);
        if (c.get(MILLISECOND) != 123
                || d.get(MILLISECOND) != 456) {
            fail("FAIL: Clones share fields");
        }
    }

    // Verify effect of Gregorian cutoff value
    @SuppressWarnings("deprecation")
    @Test
    public void TestGregorianChange768() {
        boolean b;
        GregorianCalendar c = new GregorianCalendar();
        System.out.println("With cutoff " + c.getGregorianChange());
        System.out.println(" isLeapYear(1800) = " + (b = c.isLeapYear(1800)));
        System.out.println(" (should be FALSE)");
        if (b != false) {
            fail("FAIL");
        }
        c.setGregorianChange(new Date(0, 0, 1)); // Jan 1 1900
        System.out.println("With cutoff " + c.getGregorianChange());
        System.out.println(" isLeapYear(1800) = " + (b = c.isLeapYear(1800)));
        System.out.println(" (should be TRUE)");
        if (b != true) {
            fail("FAIL");
        }
    }

    // Test the correct behavior of the disambiguation algorithm.
    @Test
    public void TestDisambiguation765() throws Exception {
        Locale savedLocale = Locale.getDefault();
        try {
            Locale.setDefault(Locale.US);
            Calendar c = Calendar.getInstance();
            c.setLenient(false);

            c.clear();
            c.set(YEAR, 1997);
            c.set(MONTH, JUNE);
            c.set(DATE, 3);

            verify765("1997 third day of June = ", c, 1997, JUNE, 3);

            c.clear();
            c.set(YEAR, 1997);
            c.set(DAY_OF_WEEK, TUESDAY);
            c.set(MONTH, JUNE);
            c.set(DAY_OF_WEEK_IN_MONTH, 1);
            verify765("1997 first Tuesday in June = ", c, 1997, JUNE, 3);

            c.setLenient(true); // for 4944795
            c.clear();
            c.set(YEAR, 1997);
            c.set(DAY_OF_WEEK, TUESDAY);
            c.set(MONTH, JUNE);
            c.set(DAY_OF_WEEK_IN_MONTH, -1);
            verify765("1997 last Tuesday in June = ", c, 1997, JUNE, 24);

            c.setLenient(false);
            IllegalArgumentException e = null;
            try {
                c.clear();
                c.set(YEAR, 1997);
                c.set(DAY_OF_WEEK, TUESDAY);
                c.set(MONTH, JUNE);
                c.set(DAY_OF_WEEK_IN_MONTH, 0);
                c.getTime();
            } catch (IllegalArgumentException ex) {
                e = ex;
            }
            verify765("1997 zero-th Tuesday in June = ", e);

            c.clear();
            c.set(YEAR, 1997);
            c.set(DAY_OF_WEEK, TUESDAY);
            c.set(MONTH, JUNE);
            c.set(WEEK_OF_MONTH, 1);
            verify765("1997 Tuesday in week 1 of June = ", c, 1997, JUNE, 3);

            c.clear();
            c.set(YEAR, 1997);
            c.set(DAY_OF_WEEK, TUESDAY);
            c.set(MONTH, JUNE);
            c.set(WEEK_OF_MONTH, 4);
            verify765("1997 Tuesday in week 4 of June = ", c, 1997, JUNE, 24);

            try {
                c.clear();
                c.set(YEAR, 1997);
                c.set(DAY_OF_WEEK, TUESDAY);
                c.set(MONTH, JUNE);
                c.set(WEEK_OF_MONTH, 1);
                verify765("1997 Tuesday in week 0 of June = ", c, 1997, JUNE, 3);
            } catch (IllegalArgumentException ex) {
                fail("FAIL: Exception seen: " + ex.getMessage());
                // ex.printStackTrace(log);
            }

            c.clear();
            c.set(YEAR, 1997);
            c.set(DAY_OF_WEEK, TUESDAY);
            c.set(WEEK_OF_YEAR, 2);
            verify765("1997 Tuesday in week 2 of year = ", c, 1997, JANUARY, 7);

            c.clear();
            c.set(YEAR, 1997);
            c.set(DAY_OF_WEEK, TUESDAY);
            c.set(WEEK_OF_YEAR, 10);
            verify765("1997 Tuesday in week 10 of year = ", c, 1997, MARCH, 4);

            try {
                c.clear();
                c.set(YEAR, 1997);
                c.set(DAY_OF_WEEK, TUESDAY);
                c.set(WEEK_OF_YEAR, 0);
                verify765("1997 Tuesday in week 0 of year = ", c, 1996, DECEMBER, 24);
                throw new Exception("Fail: WEEK_OF_YEAR 0 should be illegal");
            } catch (IllegalArgumentException ex) {
            }
        } finally {
            Locale.setDefault(savedLocale);
        }
    }

    void verify765(String msg, Calendar c, int year, int month, int day) {
        if (c.get(YEAR) == year
                && c.get(MONTH) == month
                && c.get(DATE) == day) {
            System.out.println("PASS: " + msg + c.getTime());
        } else {
            fail("FAIL: " + msg + c.getTime()
                    + "; expected "
                    + year + "/" + (month + 1) + "/" + day);
        }
    }

    // Called when e expected to be non-null
    void verify765(String msg, IllegalArgumentException e) {
        if (e == null) {
            fail("FAIL: No IllegalArgumentException for " + msg);
        } else {
            System.out.println("PASS: " + msg + "IllegalArgument as expected");
        }
    }

    // Test the behavior of GMT vs. local time
    @Test
    public void TestGMTvsLocal4064654() {
        Locale locale = Locale.getDefault();
        if (!TestUtils.usesGregorianCalendar(locale)) {
            System.out.println("Skipping this test because locale is " + locale);
            return;
        }

        // Sample output 1:
        // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 1 1 12 0 0
        // date = Wed Jan 01 04:00:00 PST 1997
        // offset for Wed Jan 01 04:00:00 PST 1997= -8hr
        test4064654(1997, 1, 1, 12, 0, 0);

        // Sample output 2:
        // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 4 16 18 30 0
        // date = Wed Apr 16 10:30:00 PDT 1997
        // offset for Wed Apr 16 10:30:00 PDT 1997= -7hr

        // Note that in sample output 2 according to the offset, the gmt time
        // of the result would be 1997 4 16 17 30 0 which is different from the
        // input of 1997 4 16 18 30 0.
        test4064654(1997, 4, 16, 18, 30, 0);
    }
    void test4064654(int yr, int mo, int dt, int hr, int mn, int sc) {
        Date date;
        Calendar gmtcal = Calendar.getInstance();
        gmtcal.setTimeZone(TimeZone.getTimeZone("Africa/Casablanca"));
        gmtcal.set(yr, mo - 1, dt, hr, mn, sc);
        gmtcal.set(MILLISECOND, 0);

        date = gmtcal.getTime();
        System.out.println("date = " + date);

        Calendar cal = Calendar.getInstance();
        cal.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
        cal.setTime(date);

        int offset = cal.getTimeZone().getOffset(cal.get(ERA),
                cal.get(YEAR),
                cal.get(MONTH),
                cal.get(DATE),
                cal.get(DAY_OF_WEEK),
                cal.get(MILLISECOND));

        System.out.println("offset for " + date + "= " + (offset / 1000 / 60 / 60.0) + "hr");

        int utc = ((cal.get(HOUR_OF_DAY) * 60
                + cal.get(MINUTE)) * 60
                + cal.get(SECOND)) * 1000
                + cal.get(MILLISECOND) - offset;

        int expected = ((hr * 60 + mn) * 60 + sc) * 1000;

        if (utc != expected) {
            fail("FAIL: Discrepancy of "
                    + (utc - expected) + " millis = "
                    + ((utc - expected) / 1000 / 60 / 60.0) + " hr");
        }
    }

    // Verify that add and set work regardless of the order in which
    // they are called.
    @Test
    public void TestAddSetOrder621() {
        @SuppressWarnings("deprecation")
        Date d = new Date(97, 4, 14, 13, 23, 45);

        Calendar cal = Calendar.getInstance();
        cal.setTime(d);
        cal.add(DATE, -5);
        cal.set(HOUR_OF_DAY, 0);
        cal.set(MINUTE, 0);
        cal.set(SECOND, 0);
        // ma feb 03 00:00:00 GMT+00:00 1997
        String s = cal.getTime().toString();

        cal = Calendar.getInstance();
        cal.setTime(d);
        cal.set(HOUR_OF_DAY, 0);
        cal.set(MINUTE, 0);
        cal.set(SECOND, 0);
        cal.add(DATE, -5);
        // ma feb 03 13:11:06 GMT+00:00 1997
        String s2 = cal.getTime().toString();

        if (s.equals(s2)) {
            System.out.println("Pass: " + s + " == " + s2);
        } else {
            fail("FAIL: " + s + " != " + s2);
        }
    }

    // Verify that add works.
    @Test
    public void TestAdd520() {
        int y = 1997, m = FEBRUARY, d = 1;
        GregorianCalendar temp = new GregorianCalendar(y, m, d);
        check520(temp, y, m, d);

        temp.add(YEAR, 1);
        y++;
        check520(temp, y, m, d);

        temp.add(MONTH, 1);
        m++;
        check520(temp, y, m, d);

        temp.add(DATE, 1);
        d++;
        check520(temp, y, m, d);

        temp.add(DATE, 2);
        d += 2;
        check520(temp, y, m, d);

        temp.add(DATE, 28);
        d = 1;
        ++m;
        check520(temp, y, m, d);
    }

    void check520(Calendar c, int y, int m, int d) {
        if (c.get(YEAR) != y
                || c.get(MONTH) != m
                || c.get(DATE) != d) {
            fail("FAILURE: Expected YEAR/MONTH/DATE of "
                    + y + "/" + (m + 1) + "/" + d
                    + "; got "
                    + c.get(YEAR) + "/"
                    + (c.get(MONTH) + 1) + "/"
                    + c.get(DATE));
        } else {
            System.out.println("Confirmed: "
                    + y + "/" + (m + 1) + "/" + d);
        }
    }

    // Verify that setting fields works.  This test fails when an exception is thrown.
    @Test
    public void TestFieldSet4781() {
        try {
            GregorianCalendar g = new GregorianCalendar();
            GregorianCalendar g2 = new GregorianCalendar();
            // At this point UTC value is set, various fields are not.
            // Now set to noon.
            g2.set(HOUR, 12);
            g2.set(MINUTE, 0);
            g2.set(SECOND, 0);
            // At this point the object thinks UTC is NOT set, but fields are set.
            // The following line will result in IllegalArgumentException because
            // it thinks the YEAR is set and it is NOT.
            if (g2.equals(g)) {
                System.out.println("Same");
            } else {
                System.out.println("Different");
            }
        } catch (IllegalArgumentException e) {
            fail("Unexpected exception seen: " + e);
        }
    }

    // Test serialization of a Calendar object
    @Test
    public void TestSerialize337() {
        Calendar cal = Calendar.getInstance();

        boolean ok = false;

        try {
            FileOutputStream f = new FileOutputStream(FILENAME);
            ObjectOutput s = new ObjectOutputStream(f);
            s.writeObject(PREFIX);
            s.writeObject(cal);
            s.writeObject(POSTFIX);
            f.close();

            FileInputStream in = new FileInputStream(FILENAME);
            ObjectInputStream t = new ObjectInputStream(in);
            String pre = (String) t.readObject();
            Calendar c = (Calendar) t.readObject();
            String post = (String) t.readObject();
            in.close();

            ok = pre.equals(PREFIX)
                    && post.equals(POSTFIX)
                    && cal.equals(c);

            File fl = new File(FILENAME);
            fl.delete();
        } catch (IOException e) {
            fail("FAIL: Exception received:");
            // e.printStackTrace(log);
        } catch (ClassNotFoundException e) {
            fail("FAIL: Exception received:");
            // e.printStackTrace(log);
        }

        if (!ok) {
            fail("Serialization of Calendar object failed.");
        }
    }
    static final String PREFIX = "abc";
    static final String POSTFIX = "def";
    static final String FILENAME = "tmp337.bin";

    // Try to zero out the seconds field
    @Test
    public void TestSecondsZero121() {
        Calendar cal = new GregorianCalendar();
        // Initialize with current date/time
        cal.setTime(new Date());
        // Round down to minute
        cal.set(SECOND, 0);
        Date d = cal.getTime();
        String s = d.toString();
        if (s.indexOf(":00 ") < 0) {
            fail("Expected to see :00 in " + s);
        }
    }

    // Try various sequences of add, set, and get method calls.
    @Test
    public void TestAddSetGet0610() {
        //
        // Error case 1:
        // - Upon initialization calendar fields, millis = System.currentTime
        // - After set is called fields are initialized, time is not
        // - Addition uses millis which are still *now*
        //
        {
            Calendar calendar = new GregorianCalendar();
            calendar.set(1993, JANUARY, 4);
            System.out.println("1A) " + value(calendar));
            calendar.add(DATE, 1);
            String v = value(calendar);
            System.out.println("1B) " + v);
            System.out.println("--) 1993/0/5");
            if (!v.equals(EXPECTED_0610)) {
                fail("Expected " + EXPECTED_0610
                        + "; saw " + v);
            }
        }

        //
        // Error case 2:
        // - Upon initialization calendar fields set, millis = 0
        // - Addition uses millis which are still 1970, 0, 1
        //
        {
            Calendar calendar = new GregorianCalendar(1993, JANUARY, 4);
            System.out.println("2A) " + value(calendar));
            calendar.add(DATE, 1);
            String v = value(calendar);
            System.out.println("2B) " + v);
            System.out.println("--) 1993/0/5");
            if (!v.equals(EXPECTED_0610)) {
                fail("Expected " + EXPECTED_0610
                        + "; saw " + v);
            }
        }

        //
        // Error case 3:
        // - Upon initialization calendar fields, millis = 0
        // - getTime( ) is called which forces the millis to be set
        // - Addition uses millis which are correct
        //
        {
            Calendar calendar = new GregorianCalendar(1993, JANUARY, 4);
            System.out.println("3A) " + value(calendar));
            calendar.getTime();
            calendar.add(DATE, 1);
            String v = value(calendar);
            System.out.println("3B) " + v);
            System.out.println("--) 1993/0/5");
            if (!v.equals(EXPECTED_0610)) {
                fail("Expected " + EXPECTED_0610
                        + "; saw " + v);
            }
        }
    }
    static String value(Calendar calendar) {
        return (calendar.get(YEAR) + "/"
                + calendar.get(MONTH) + "/"
                + calendar.get(DATE));
    }
    static String EXPECTED_0610 = "1993/0/5";

    // Test that certain fields on a certain date are as expected.
    @Test
    public void TestFields060() {
        int year = 1997;
        int month = OCTOBER;  //october
        int dDate = 22;   //DAYOFWEEK should return 3 for Wednesday
        GregorianCalendar calendar = null;

        calendar = new GregorianCalendar(year, month, dDate);
        for (int i = 0; i < EXPECTED_FIELDS.length;) {
            int field = EXPECTED_FIELDS[i++];
            int expected = EXPECTED_FIELDS[i++];
            if (calendar.get(field) != expected) {
                fail("Expected field " + field + " to have value " + expected
                        + "; received " + calendar.get(field) + " instead");
            }
        }
    }
    static int[] EXPECTED_FIELDS = {
        YEAR, 1997,
        MONTH, OCTOBER,
        DAY_OF_MONTH, 22,
        DAY_OF_WEEK, WEDNESDAY,
        DAY_OF_WEEK_IN_MONTH, 4,
        DAY_OF_YEAR, 295};

    static final String[] calendarFieldNames = {
        /*  0 */ "ERA",
        /*  1 */ "YEAR",
        /*  2 */ "MONTH",
        /*  3 */ "WEEK_OF_YEAR",
        /*  4 */ "WEEK_OF_MONTH",
        /*  5 */ "DAY_OF_MONTH",
        /*  6 */ "DAY_OF_YEAR",
        /*  7 */ "DAY_OF_WEEK",
        /*  8 */ "DAY_OF_WEEK_IN_MONTH",
        /*  9 */ "AM_PM",
        /* 10 */ "HOUR",
        /* 11 */ "HOUR_OF_DAY",
        /* 12 */ "MINUTE",
        /* 13 */ "SECOND",
        /* 14 */ "MILLISECOND",
        /* 15 */ "ZONE_OFFSET",
        /* 16 */ "DST_OFFSET"};

    // Verify that the fields are as expected (mostly zero) at the epoch start.
    // Note that we adjust for the default timezone to get most things to zero.
    @Test
    public void TestEpochStartFields() {
        String[][] lt = {
            {"en", "US", "US/Pacific"},        /* First day = 1, Minimum day = 1 */
            {"en", "US", "America/Anchorage"}, /* First day = 1, Minimum day = 1 */
            {"en", "TO", "Pacific/Tongatapu"}, /* First day = 1, Minimum day = 1 */
            {"en", "MH", "Pacific/Majuro"},    /* First day = 1, Minimum day = 1 */
            {"ja", "JP", "Asia/Tokyo"},        /* First day = 1, Minimum day = 1 */
            {"iw", "IL", "Asia/Jerusalem"},    /* First day = 1, Minimum day = 1 */
            {"hi", "IN", "Asia/Jakarta"},      /* First day = 1, Minimum day = 1 */
            {"en", "GB", "Europe/London"},     /* First day = 2, Minimum day = 1 */
            {"en", "GB", "GMT"},               /* First day = 2, Minimum day = 1 */
            {"de", "DE", "Europe/Berlin"},     /* First day = 2, Minimum day = 4 */
            {"ar", "EG", "Africa/Cairo"}};     /* First day = 7, Minimum day = 1 */

        int[][] goldenData = {
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0},
            {1, 1969, 11, 1, 5, 31, 365, 4, 5, 1, 11, 23, 0, 0, 0, -36000000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 46800000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 43200000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 32400000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 25200000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 1, 1, 0, 0, 0, 3600000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 3600000, 0},
            {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0}};

        Locale savedLocale = Locale.getDefault();
        TimeZone savedTimeZone = TimeZone.getDefault();

        try {
            for (int j = 0; j < lt.length; j++) {
                Locale l = Locale.of(lt[j][0], lt[j][1]);
                TimeZone z = TimeZone.getTimeZone(lt[j][2]);
                Locale.setDefault(l);
                TimeZone.setDefault(z);
                Calendar c = Calendar.getInstance();
                Date d = new Date(-z.getRawOffset());

                int val;
                int[] EPOCH_FIELDS = goldenData[j];
                c.setTime(d);

                boolean err = false;
                for (int i = 0; i < calendarFieldNames.length; ++i) {
                    if ((val = c.get(i)) != EPOCH_FIELDS[i]) {
                        fail("Wrong value: " + val
                                + " for field(" + calendarFieldNames[i]
                                + "), expected: " + EPOCH_FIELDS[i]);
                        err = true;
                    }
                }
                if (err) {
                    fail("Failed: \n\tDate=" + d + "\n\tTimeZone=" + z
                            + "\n\tLocale=" + l + "\n\tCalendar=" + c);
                }
            }
        } finally {
            Locale.setDefault(savedLocale);
            TimeZone.setDefault(savedTimeZone);
        }
    }

    // Verify that as you add days to the calendar (e.g., 24 day periods),
    // the day of the week shifts in the expected pattern.
    @Test
    public void TestDOWProgression() {
        Calendar cal
                = new GregorianCalendar(1972, OCTOBER, 26);
        marchByDelta(cal, 24); // Last parameter must be != 0 modulo 7
    }

    // Supply a delta which is not a multiple of 7.
    void marchByDelta(Calendar cal, int delta) {
        Calendar cur = (Calendar) cal.clone();
        int initialDOW = cur.get(DAY_OF_WEEK);
        int DOW, newDOW = initialDOW;
        do {
            DOW = newDOW;
            System.out.println("DOW = " + DOW + "  " + cur.getTime());

            cur.add(DAY_OF_WEEK, delta);
            newDOW = cur.get(DAY_OF_WEEK);
            int expectedDOW = 1 + (DOW + delta - 1) % 7;
            if (newDOW != expectedDOW) {
                fail("Day of week should be " + expectedDOW
                        + " instead of " + newDOW + " on " + cur.getTime());
                return;
            }
        } while (newDOW != initialDOW);
    }

    @Test
    public void TestActualMinMax() {
        Calendar cal = new GregorianCalendar(1967, MARCH, 10);
        cal.setFirstDayOfWeek(SUNDAY);
        cal.setMinimalDaysInFirstWeek(3);

        if (cal.getActualMinimum(DAY_OF_MONTH) != 1) {
            fail("Actual minimum date for 3/10/1967 should have been 1; got "
                    + cal.getActualMinimum(DAY_OF_MONTH));
        }
        if (cal.getActualMaximum(DAY_OF_MONTH) != 31) {
            fail("Actual maximum date for 3/10/1967 should have been 31; got "
                    + cal.getActualMaximum(DAY_OF_MONTH));
        }

        cal.set(MONTH, FEBRUARY);
        if (cal.getActualMaximum(DAY_OF_MONTH) != 28) {
            fail("Actual maximum date for 2/10/1967 should have been 28; got "
                    + cal.getActualMaximum(DAY_OF_MONTH));
        }
        if (cal.getActualMaximum(DAY_OF_YEAR) != 365) {
            fail("Number of days in 1967 should have been 365; got "
                    + cal.getActualMaximum(DAY_OF_YEAR));
        }

        cal.set(YEAR, 1968);
        if (cal.getActualMaximum(DAY_OF_MONTH) != 29) {
            fail("Actual maximum date for 2/10/1968 should have been 29; got "
                    + cal.getActualMaximum(DAY_OF_MONTH));
        }
        if (cal.getActualMaximum(DAY_OF_YEAR) != 366) {
            fail("Number of days in 1968 should have been 366; got "
                    + cal.getActualMaximum(DAY_OF_YEAR));
        }
        // Using week settings of SUNDAY/3 (see above)
        if (cal.getActualMaximum(WEEK_OF_YEAR) != 52) {
            fail("Number of weeks in 1968 should have been 52; got "
                    + cal.getActualMaximum(WEEK_OF_YEAR));
        }

        cal.set(YEAR, 1976);
        // Using week settings of SUNDAY/3 (see above)
        if (cal.getActualMaximum(WEEK_OF_YEAR) != 53) {
            fail("Number of weeks in 1976 should have been 53; got "
                    + cal.getActualMaximum(WEEK_OF_YEAR));
        }
    }

    @Test
    public void TestRoll() {
        Calendar cal = new GregorianCalendar(1997, JANUARY, 31);

        int[] dayValues = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31};

        for (int i = 0; i < dayValues.length; i++) {
            Calendar cal2 = (Calendar) cal.clone();
            cal2.roll(MONTH, i);
            if (cal2.get(DAY_OF_MONTH) != dayValues[i]) {
                fail("Rolling the month in 1/31/1997 up by " + i + " should have yielded "
                        + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "
                        + ((i + 1) % 12) + "/" + cal2.get(DAY_OF_MONTH) + "/1997.");
            }
        }

        cal.set(1996, FEBRUARY, 29);

        int[] monthValues = {1, 2, 2, 2, 1, 2, 2, 2, 1, 2};
        int[] dayValues2 = {29, 1, 1, 1, 29, 1, 1, 1, 29, 1};

        for (int i = 0; i < dayValues2.length; i++) {
            Calendar cal2 = (Calendar) cal.clone();
            cal2.roll(YEAR, i);
            if (cal2.get(DAY_OF_MONTH) != dayValues2[i] || cal2.get(MONTH)
                    != monthValues[i]) {
                fail("Rolling the year in 2/29/1996 up by " + i + " should have yielded "
                        + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"
                        + (1996 + i) + ", but actually yielded "
                        + (cal2.get(MONTH) + 1) + "/"
                        + cal2.get(DAY_OF_MONTH) + "/" + (1996 + i) + ".");
            }
        }

        // Test rolling hour of day
        cal.set(HOUR_OF_DAY, 0);
        cal.roll(HOUR_OF_DAY, -2);
        int f = cal.get(HOUR_OF_DAY);
        if (f != 22) {
            fail("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");
        }
        cal.roll(HOUR_OF_DAY, 5);
        f = cal.get(HOUR_OF_DAY);
        if (f != 3) {
            fail("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");
        }
        cal.roll(HOUR_OF_DAY, 21);
        f = cal.get(HOUR_OF_DAY);
        if (f != 0) {
            fail("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");
        }

        // Test rolling hour
        cal.set(HOUR_OF_DAY, 0);
        cal.roll(HOUR, -2);
        f = cal.get(HOUR);
        if (f != 10) {
            fail("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");
        }
        cal.roll(HOUR, 5);
        f = cal.get(HOUR);
        if (f != 3) {
            fail("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");
        }
        cal.roll(HOUR, 9);
        f = cal.get(HOUR);
        if (f != 0) {
            fail("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");
        }
    }

    /*
     * Confirm that multiple calls to Calendar.set() works correctly.
     */
    @Test
    public void Test4374886() {
        Locale savedLocale = Locale.getDefault();
        TimeZone savedTimeZone = TimeZone.getDefault();

        try {
            Locale.setDefault(Locale.US);
            TimeZone.setDefault(TimeZone.getTimeZone("PST"));

            Calendar cal = Calendar.getInstance();
            cal.set(YEAR, 2001);
            cal.set(MONTH, OCTOBER);
            cal.set(WEEK_OF_YEAR, 4);
            cal.set(DAY_OF_WEEK, 2);

            if (cal.get(YEAR) != 2001
                    || cal.get(MONTH) != JANUARY
                    || cal.get(DATE) != 22
                    || cal.get(DAY_OF_WEEK) != MONDAY) {
                fail("Failed : got " + cal.getTime() + ", expected Mon Jan 22, 2001");
            }
        } finally {
            Locale.setDefault(savedLocale);
            TimeZone.setDefault(savedTimeZone);
        }
    }

    @Test
    public void TestClonedSharedZones() throws NoSuchFieldException, IllegalAccessException {
        Field zone = Calendar.class.getDeclaredField("zone");
        zone.setAccessible(true);
        Field sharedZone = Calendar.class.getDeclaredField("sharedZone");
        sharedZone.setAccessible(true);

        // create a new calendar with any date, and clone it.
        Calendar c1 = new GregorianCalendar();
        Calendar c2 = (Calendar) c1.clone();

        // c1 should have a shared zone
        if (!sharedZone.getBoolean(c1)) {
            fail("Failed : c1.sharedZone == false");
        } else {
            // c2 should have a shared zone too
            if (!sharedZone.getBoolean(c2)) {
                fail("Failed : c2.sharedZone == false");
            } else if (zone.get(c1) != zone.get(c2)) {
                fail("Failed : c1.zone != c2.zone");
            }
        }
    }
}

//eof