/*

 * 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.

 */

import java.text.*;

import java.util.*;

import java.io.*;

/**

 * @test

 * @bug 4029195 4052408 4056591 4059917 4060212 4061287 4065240 4071441 4073003

 * 4089106 4100302 4101483 4103340 4103341 4104136 4104522 4106807 4108407

 * 4134203 4138203 4148168 4151631 4151706 4153860 4162071 4182066 4209272 4210209

 * 4213086 4250359 4253490 4266432 4406615 4413980 8008577

 * @library /java/text/testlib

 * @run main/othervm -Djava.locale.providers=COMPAT,SPI DateFormatRegression

 */

public class DateFormatRegression extends IntlTest {

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

        new DateFormatRegression().run(args);

    }

    public void Test4029195() {

        Date today = new Date();

        logln("today: " + today);

        SimpleDateFormat sdf = (SimpleDateFormat)SimpleDateFormat.getDateInstance();

        logln("pattern: " + sdf.toPattern());

        logln("today: " + sdf.format(today));

        sdf.applyPattern("G yyyy DDD");

        String todayS = sdf.format(today);

        logln("today: " + todayS);

        try {

            today = sdf.parse(todayS);

            logln("today date: " + today);

        } catch(Exception e) {

            logln("Error reparsing date: " + e.getMessage());

        }

        try {

            String rt = sdf.format(sdf.parse(todayS));

            logln("round trip: " + rt);

            if (!rt.equals(todayS)) errln("Fail: Want " + todayS + " Got " + rt);

        }

        catch (ParseException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

    }

    public void Test4052408() {

        DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.SHORT,

                                                        DateFormat.SHORT, Locale.US);

        Date date = new Date(97, Calendar.MAY, 3, 8, 55);

        String str;

        logln(str = fmt.format(date));

        if (!str.equals("5/3/97 8:55 AM"))

            errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);

        Hashtable expected = new Hashtable();

        expected.put(new Integer(DateFormat.MONTH_FIELD), "5");

        expected.put(new Integer(DateFormat.DATE_FIELD), "3");

        expected.put(new Integer(DateFormat.YEAR_FIELD), "97");

        expected.put(new Integer(DateFormat.HOUR1_FIELD), "8");

        expected.put(new Integer(DateFormat.MINUTE_FIELD), "55");

        expected.put(new Integer(DateFormat.AM_PM_FIELD), "AM");

        StringBuffer buf = new StringBuffer();

        String fieldNames[] = {

            "ERA_FIELD",

            "YEAR_FIELD",

            "MONTH_FIELD",

            "DATE_FIELD",

            "HOUR_OF_DAY1_FIELD",

            "HOUR_OF_DAY0_FIELD",

            "MINUTE_FIELD",

            "SECOND_FIELD",

            "MILLISECOND_FIELD",

            "DAY_OF_WEEK_FIELD",

            "DAY_OF_YEAR_FIELD",

            "DAY_OF_WEEK_IN_MONTH_FIELD",

            "WEEK_OF_YEAR_FIELD",

            "WEEK_OF_MONTH_FIELD",

            "AM_PM_FIELD",

            "HOUR1_FIELD",

            "HOUR0_FIELD",

            "TIMEZONE_FIELD",

        };

        boolean pass = true;

        for (int i=0; i<=17; ++i) {

            FieldPosition pos = new FieldPosition(i);

            fmt.format(date, buf, pos);

            char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];

            buf.getChars(pos.getBeginIndex(), pos.getEndIndex(), dst, 0);

            str = new String(dst);

            log(i + ": " + fieldNames[i] +

                             ", \"" + str + "\", " +

                             pos.getBeginIndex() + ", " +

                             pos.getEndIndex());

            String exp = (String) expected.get(new Integer(i));

            if ((exp == null && str.length() == 0) ||

                str.equals(exp))

                logln(" ok");

            else {

                logln(" expected " + exp);

                pass = false;

            }

        }

        if (!pass) errln("Fail: FieldPosition not set right by DateFormat");

    }

    /**

     * Verify the function of the [s|g]et2DigitYearStart() API.

     */

    public void Test4056591() {

        try {

            SimpleDateFormat fmt = new SimpleDateFormat("yyMMdd", Locale.US);

            Date start = new Date(1809-1900, Calendar.DECEMBER, 25);

            fmt.set2DigitYearStart(start);

            if (!fmt.get2DigitYearStart().equals(start))

                errln("get2DigitYearStart broken");

            Object[] DATA = {

                "091225", new Date(1809-1900, Calendar.DECEMBER, 25),

                "091224", new Date(1909-1900, Calendar.DECEMBER, 24),

                "091226", new Date(1809-1900, Calendar.DECEMBER, 26),

                "611225", new Date(1861-1900, Calendar.DECEMBER, 25),

            };

            for (int i=0; i<DATA.length; i+=2) {

                String s = (String) DATA[i];

                Date exp = (Date) DATA[i+1];

                Date got = fmt.parse(s);

                logln(s + " -> " + got + "; exp " + exp);

                if (!got.equals(exp)) errln("set2DigitYearStart broken");

            }

        }

        catch (ParseException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

    }

    public void Test4059917() {

        if (Locale.getDefault().equals(new Locale("hi", "IN"))) {

            return;

        }

        SimpleDateFormat fmt;

        String myDate;

        fmt = new SimpleDateFormat( "yyyy/MM/dd" );

        myDate = "1997/01/01";

        aux917( fmt, myDate );

        fmt = new SimpleDateFormat( "yyyyMMdd" );

        myDate = "19970101";

        aux917( fmt, myDate );

    }

    void aux917( SimpleDateFormat fmt, String str ) {

        try {

            logln( "==================" );

            logln( "testIt: pattern=" + fmt.toPattern() +

                   " string=" + str );

            Object o;

            o = fmt.parseObject( str );

            logln( "Parsed object: " + o );

            String formatted = fmt.format( o );

            logln( "Formatted string: " + formatted );

            if (!formatted.equals(str)) errln("Fail: Want " + str + " Got " + formatted);

        }

        catch (ParseException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

    }

    public void Test4060212() {

      Locale savedLocale = Locale.getDefault();

      Locale.setDefault(Locale.US);

      try {

        String dateString = "1995-040.05:01:29";

        logln( "dateString= " + dateString );

        logln("Using yyyy-DDD.hh:mm:ss");

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-DDD.hh:mm:ss");

        ParsePosition pos = new ParsePosition(0);

        Date myDate = formatter.parse( dateString, pos );

        String myString = DateFormat.getDateTimeInstance( DateFormat.FULL,

                                                          DateFormat.LONG).format( myDate );

        logln( myString );

        Calendar cal = new GregorianCalendar();

        cal.setTime(myDate);

        if (cal.get(Calendar.DAY_OF_YEAR) != 40)

            errln("Fail: Got " + cal.get(Calendar.DAY_OF_YEAR) +

                                " Want 40");

        logln("Using yyyy-ddd.hh:mm:ss");

        formatter = new SimpleDateFormat("yyyy-ddd.hh:mm:ss");

        pos = new ParsePosition(0);

        myDate = formatter.parse( dateString, pos );

        myString = DateFormat.getDateTimeInstance( DateFormat.FULL,

                                                   DateFormat.LONG).format( myDate );

        logln( myString );

        cal.setTime(myDate);

        if (cal.get(Calendar.DAY_OF_YEAR) != 40)

            errln("Fail: Got " + cal.get(Calendar.DAY_OF_YEAR) +

                                " Want 40");

      }

      finally {

         Locale.setDefault(savedLocale);

      }

    }

    public void Test4061287() {

        SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy");

        try {

            logln(df.parse("35/01/1971").toString());

        }

        catch (ParseException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

        df.setLenient(false);

        boolean ok = false;

        try {

            logln(df.parse("35/01/1971").toString());

        } catch (ParseException e) {ok=true;}

        if (!ok) errln("Fail: Lenient not working");

    }

    public void Test4065240() {

        Date curDate;

        DateFormat shortdate, fulldate;

        String strShortDate, strFullDate;

        Locale saveLocale = Locale.getDefault();

        TimeZone saveZone = TimeZone.getDefault();

        try {

            Locale curLocale = new Locale("de","DE");

            Locale.setDefault(curLocale);

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

            curDate = new Date(98, 0, 1);

            shortdate = DateFormat.getDateInstance(DateFormat.SHORT);

            fulldate = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG

                                                      );

            strShortDate = new String("The current date (short form) is " + shortdate.

                                      format(curDate));

            strFullDate = new String("The current date (long form) is " + fulldate.format(curDate));

            logln(strShortDate);

            logln(strFullDate);

            // UPDATE THIS AS ZONE NAME RESOURCE FOR <EST> in de_DE is updated

            if (!strFullDate.endsWith("EST")

                    && !strFullDate.endsWith("GMT-05:00")) {

                errln("Fail: Want GMT-05:00");

            }

        }

        finally {

            Locale.setDefault(saveLocale);

            TimeZone.setDefault(saveZone);

        }

    }

    /*

      DateFormat.equals is too narrowly defined.  As a result, MessageFormat

      does not work correctly.  DateFormat.equals needs to be written so

      that the Calendar sub-object is not compared using Calendar.equals,

      but rather compared for equivalency.  This may necessitate adding a

      (package private) method to Calendar to test for equivalency.

      Currently this bug breaks MessageFormat.toPattern

      */

    public void Test4071441() {

        DateFormat fmtA = DateFormat.getInstance();

        DateFormat fmtB = DateFormat.getInstance();

        Calendar calA = fmtA.getCalendar();

        Calendar calB = fmtB.getCalendar();

        Date epoch = new Date(0);

        Date xmas = new Date(61, Calendar.DECEMBER, 25);

        calA.setTime(epoch);

        calB.setTime(epoch);

        if (!calA.equals(calB))

            errln("Fail: Can't complete test; Calendar instances unequal");

        if (!fmtA.equals(fmtB))

            errln("Fail: DateFormat unequal when Calendars equal");

        calB.setTime(xmas);

        if (calA.equals(calB))

            errln("Fail: Can't complete test; Calendar instances equal");

        if (!fmtA.equals(fmtB))

            errln("Fail: DateFormat unequal when Calendars equivalent");

        logln("DateFormat.equals ok");

    }

    /* The java.text.DateFormat.parse(String) method expects for the

      US locale a string formatted according to mm/dd/yy and parses it

      correctly.

      When given a string mm/dd/yyyy it only parses up to the first

      two y's, typically resulting in a date in the year 1919.

      Please extend the parsing method(s) to handle strings with

      four-digit year values (probably also applicable to various

      other locales.  */

    public void Test4073003() {

        try {

            DateFormat fmt = DateFormat.getDateInstance(DateFormat.SHORT, Locale.US);

            String[] tests = { "12/25/61", "12/25/1961", "4/3/2010", "4/3/10" };

            for (int i=0; i<tests.length; i+=2) {

                Date d = fmt.parse(tests[i]);

                Date dd = fmt.parse(tests[i+1]);

                String s = fmt.format(d);

                String ss = fmt.format(dd);

                if (!d.equals(dd))

                    errln("Fail: " + d + " != " + dd);

                if (!s.equals(ss))

                    errln("Fail: " + s + " != " + ss);

                logln("Ok: " + s + " " + d);

            }

        }

        catch (ParseException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

    }

    public void Test4089106() {

        TimeZone def = TimeZone.getDefault();

        try {

            TimeZone z = new SimpleTimeZone((int)(1.25 * 3600000), "FAKEZONE");

            TimeZone.setDefault(z);

            SimpleDateFormat f = new SimpleDateFormat();

            if (!f.getTimeZone().equals(z))

                errln("Fail: SimpleTimeZone should use TimeZone.getDefault()");

        }

        finally {

            TimeZone.setDefault(def);

        }

    }

    public void Test4100302() {

        Locale[] locales = new Locale[] {

            Locale.CANADA,

            Locale.CANADA_FRENCH,

            Locale.CHINA,

            Locale.CHINESE,

            Locale.ENGLISH,

            Locale.FRANCE,

            Locale.FRENCH,

            Locale.GERMAN,

            Locale.GERMANY,

            Locale.ITALIAN,

            Locale.ITALY,

            Locale.JAPAN,

            Locale.JAPANESE,

            Locale.KOREA,

            Locale.KOREAN,

            Locale.PRC,

            Locale.SIMPLIFIED_CHINESE,

            Locale.TAIWAN,

            Locale.TRADITIONAL_CHINESE,

            Locale.UK,

            Locale.US

            };

        try {

            boolean pass = true;

            for(int i = 0; i < locales.length; i++) {

                Format format = DateFormat.getDateTimeInstance(DateFormat.FULL,

                                                               DateFormat.FULL, locales[i]);

                byte[] bytes;

                ByteArrayOutputStream baos = new ByteArrayOutputStream();

                ObjectOutputStream oos = new ObjectOutputStream(baos);

                oos.writeObject(format);

                oos.flush();

                baos.close();

                bytes = baos.toByteArray();

                ObjectInputStream ois =

                    new ObjectInputStream(new ByteArrayInputStream(bytes));

                if (!format.equals(ois.readObject())) {

                    pass = false;

                    logln("DateFormat instance for locale " +

                          locales[i] + " is incorrectly serialized/deserialized.");

                } else {

                    logln("DateFormat instance for locale " +

                          locales[i] + " is OKAY.");

                }

            }

            if (!pass) errln("Fail: DateFormat serialization/equality bug");

        }

        catch (IOException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

        catch (ClassNotFoundException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

    }

    /**

     * Test whether DataFormat 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);

                Format format = DateFormat.getDateTimeInstance(DateFormat.FULL,

                                                               DateFormat.FULL);

                byte[] bytes;

                ByteArrayOutputStream baos = new ByteArrayOutputStream();

                ObjectOutputStream oos = new ObjectOutputStream(baos);

                oos.writeObject(format);

                oos.flush();

                baos.close();

                bytes = baos.toByteArray();

                ObjectInputStream ois =

                    new ObjectInputStream(new ByteArrayInputStream(bytes));

                if (!format.equals(ois.readObject())) {

                    pass = false;

                    logln("DateFormat instance which uses TimeZone <" +

                          IDs[i] + "> is incorrectly serialized/deserialized.");

                } else {

                    logln("DateFormat instance which uses TimeZone <" +

                          IDs[i] + "> is correctly serialized/deserialized.");

                }

            }

            if (!pass) {

                errln("Fail: DateFormat serialization/equality bug");

            }

        }

        catch (IOException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

        catch (ClassNotFoundException e) {

            errln("Fail: " + e);

            e.printStackTrace();

        }

        finally {

            TimeZone.setDefault(savedTimeZone);

        }

    }

    public void Test4101483() {

        SimpleDateFormat sdf = new SimpleDateFormat("z", Locale.US);

        FieldPosition fp = new FieldPosition(DateFormat.TIMEZONE_FIELD);

        Date d= new Date(9234567890L);

        StringBuffer buf = new StringBuffer("");

        logln(sdf.format(d, buf, fp).toString());

        logln(d + " => " + buf);

        logln("beginIndex = " + fp.getBeginIndex());

        logln("endIndex = " + fp.getEndIndex());

        if (fp.getBeginIndex() == fp.getEndIndex()) errln("Fail: Empty field");

    }

    /**

     * Bug 4103340

     * Bug 4138203

     * This bug really only works in Locale.US, since that's what the locale

     * used for Date.toString() is.  Bug 4138203 reports that it fails on Korean

     * NT; it would actually have failed on any non-US locale.  Now it should

     * work on all locales.

     */

    public void Test4103340() {

        // choose a date that is the FIRST of some month

        // and some arbitrary time

        Date d=new Date(97, 3, 1, 1, 1, 1);

        SimpleDateFormat df=new SimpleDateFormat("MMMM", Locale.US);

        String s = d.toString();

        String s2 = df.format(d);

        logln("Date="+s);

        logln("DF="+s2);

        if (s.indexOf(s2.substring(0,2)) == -1)

            errln("Months should match");

    }

    public void Test4103341() {

        TimeZone saveZone  =TimeZone.getDefault();

        try {

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

            SimpleDateFormat simple = new SimpleDateFormat("MM/dd/yyyy HH:mm");

            if (!simple.getTimeZone().equals(TimeZone.getDefault()))

                errln("Fail: SimpleDateFormat not using default zone");

        }

        finally {