diff -r 4ebc2e2fb97c -r 71c04702a3d5 test/jdk/java/util/Calendar/FieldStateTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/jdk/java/util/Calendar/FieldStateTest.java Tue Sep 12 19:03:39 2017 +0200 @@ -0,0 +1,219 @@ +/* + * 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 4860664 4916815 4867075 + * @library /java/text/testlib + * @build Koyomi + * @run main FieldStateTest + * @summary Unit tests for internal fields states. + */ + +import java.util.Date; +import java.util.Locale; +import java.util.TimeZone; + +import static java.util.Calendar.*; + +public class FieldStateTest extends IntlTest { + + public static void main(String[] args) throws Exception { + Locale reservedLocale = Locale.getDefault(); + TimeZone reservedTimeZone = TimeZone.getDefault(); + try { + TimeZone.setDefault(TimeZone.getTimeZone("GMT")); + Locale.setDefault(Locale.US); + + new FieldStateTest().run(args); + } finally { + // restore the reserved locale and time zone + Locale.setDefault(reservedLocale); + TimeZone.setDefault(reservedTimeZone); + } + } + + public void TestFieldState() { + Koyomi cal = new Koyomi(); + logln("Right after instantialtion:"); + if (!cal.checkAllSet()) { + errln(cal.getMessage()); + } + + logln("Set date to 2003/10/31 after the instantiation:"); + cal.set(2003, OCTOBER, 31); + // let cal calculate the time + cal.getTime(); + // At this point, all fields have to be recalculated and + // happen to have the set-state from the instantiation. The + // three fields should have "externally set" and the rest of + // the fields have "computed". But we can't distinguish them + // outside the package. + if (!cal.checkAllSet()) { + errln(cal.getMessage()); + } + // Make sure that the correct date was produced. + if (!cal.checkInternalDate(2003, OCTOBER, 31, FRIDAY)) { + errln(cal.getMessage()); + } + + logln("Change to Monday of the week, which is 2003/10/27:"); + cal.set(DAY_OF_WEEK, MONDAY); + cal.getTime(); + if (!cal.checkDate(2003, OCTOBER, 27)) { + errln(cal.getMessage()); + } + + // The same operation didn't work after calling clear() before + // 1.5 because the set-state was just depends on its previous + // operations. After the instantiation, all the fields are set + // to "computed". But after calling clear(), the state becomes + // "unset". + logln("Set to 2003/10/31 after clear():"); + cal.clear(); + cal.set(2003, OCTOBER, 31); + cal.getTime(); + cal.set(DAY_OF_WEEK, MONDAY); + if (!cal.checkDate(2003, OCTOBER, 27, MONDAY)) { + errln(cal.getMessage()); + } + + logln("Set to 2003/10/31 after clear(), then to the 51st week of year (12/19):"); + cal.clear(); + cal.set(2003, OCTOBER, 31); + cal.getTime(); + cal.set(WEEK_OF_YEAR, 51); + if (!cal.checkFieldValue(WEEK_OF_YEAR, 51)) { + errln(cal.getMessage()); + } + if (!cal.checkDate(2003, DECEMBER, 19, FRIDAY)) { + errln(cal.getMessage()); + } + + logln("Set to 2003/10 Mon of 4th week (10/20: 43rd week of year, 293rd day):"); + cal.clear(); + cal.set(YEAR, 2003); + cal.set(MONTH, OCTOBER); + cal.set(DAY_OF_WEEK, MONDAY); + cal.set(WEEK_OF_MONTH, 4); + cal.getTime(); + if (!cal.checkFieldValue(DAY_OF_MONTH, 20)) { + errln(cal.getMessage()); + } + if (!cal.checkFieldValue(DAY_OF_YEAR, 293)) { + errln(cal.getMessage()); + } + if (!cal.checkFieldValue(WEEK_OF_YEAR, 43)) { + errln(cal.getMessage()); + } + + logln("Set to 2003/10 Mon of 43rd week of year (10/20: 4th week of month, 293rd day):"); + cal.clear(); + cal.set(YEAR, 2003); + cal.set(DAY_OF_WEEK, MONDAY); + cal.set(WEEK_OF_YEAR, 43); + cal.getTime(); + if (!cal.checkDate(2003, OCTOBER, 20, MONDAY)) { + errln(cal.getMessage()); + } + if (!cal.checkFieldValue(WEEK_OF_MONTH, 4)) { + errln(cal.getMessage()); + } + if (!cal.checkFieldValue(DAY_OF_YEAR, 293)) { + errln(cal.getMessage()); + } + + logln("Set day of week to SUNDAY and date to 2003/10/31. " + + "Then, getTime and set week of year to 43."); + + @SuppressWarnings("deprecation") + Date d = new Date(2003 - 1990, OCTOBER, 31); + cal.setTime(d); + cal.set(DAY_OF_WEEK, SUNDAY); + cal.set(2003, OCTOBER, 31); // 2003/10/31 is Friday. + cal.set(ZONE_OFFSET, 0); + cal.set(DST_OFFSET, 0); + + // This call should change the day of week to FRIDAY since the + // selected field combination should be YEAR, MONTH and + // DAY_OF_MONTH. The other calendar fields must be normalized + // with the selected date. + cal.getTime(); + cal.set(WEEK_OF_YEAR, 43); + if (!cal.checkDate(2003, OCTOBER, 24, FRIDAY)) { + errln(cal.getMessage()); + } + } + + /* + * 4916815: REGRESSION: Problem with java.util.Calendar VM 1.4.2-b28 + */ + public void Test4916815() { + logln("Set date to 2003/9/26 (Fri). Roll to Aug and back to Sep. " + + "Set dayofweek to Sunday which should be 2003/9/21."); + Koyomi cal = new Koyomi(); + cal.clear(); + // 2003/9/26 (Fri) + cal.set(2003, SEPTEMBER, 26); + // Go to August then back to September + cal.roll(MONTH, -1); + cal.roll(MONTH, +1); + Koyomi cal2 = (Koyomi) cal.clone(); + cal2.getTime(); + // Sunday of the week should be 2003/9/21. + cal2.set(DAY_OF_WEEK, SUNDAY); + if (!cal2.checkDate(2003, SEPTEMBER, 21, SUNDAY)) { + errln(cal2.getMessage()); + } + } + + /* + * 4867075: GregorianCalendar get() calls complete() internally, should getTime() too? + */ + public void Test4867075() { + Koyomi cal = new Koyomi(Locale.US); + cal.clear(); + cal.set(YEAR, 2004); + cal.set(WEEK_OF_YEAR, 1); + checkDate(cal, SUNDAY, 2003, DECEMBER, 28); + checkDate(cal, MONDAY, 2003, DECEMBER, 29); + checkDate(cal, TUESDAY, 2003, DECEMBER, 30); + checkDate(cal, WEDNESDAY, 2003, DECEMBER, 31); + checkDate(cal, THURSDAY, 2004, JANUARY, 1); + checkDate(cal, FRIDAY, 2004, JANUARY, 2); + checkDate(cal, SATURDAY, 2004, JANUARY, 3); + } + + private void checkDate(Koyomi cal, int dayOfWeek, + int expectedYear, int expectedMonth, int expectedDayOfMonth) { + cal.set(DAY_OF_WEEK, dayOfWeek); + cal.getTime(); + if (!cal.checkInternalDate(expectedYear, expectedMonth, expectedDayOfMonth, dayOfWeek)) { + errln(cal.getMessage()); + } + } + + static String toHexString(int x) { + return Integer.toHexString(x); + } +}