luni/src/test/java/libcore/java/util/GregorianCalendarTest.java - platform/libcore - Git at Google

 /*
  * Copyright (C) 2013 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */

 package libcore.java.util;

 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 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 junit.framework.TestCase;

 public class GregorianCalendarTest extends TestCase {

     private static final TimeZone LOS_ANGELES = TimeZone.getTimeZone("America/Los_Angeles");

     private static final TimeZone LONDON = TimeZone.getTimeZone("Europe/London");

     private static final int HOUR_IN_MILLIS = 3600000;

     private static final SimpleTimeZone CUSTOM_LOS_ANGELES_TIME_ZONE = new SimpleTimeZone(-28800000,
             "Custom America/Los_Angeles",
             Calendar.MARCH, 9, 0, hours(2),
             Calendar.NOVEMBER, 2, 0, hours(2),
             hours(1));

     private Locale defaultLocale;

     @Override
     public void setUp() throws Exception {
         super.setUp();
         defaultLocale = Locale.getDefault();
         // Most tests are locale independent, but locale does affect start-of-week.
         Locale.setDefault(Locale.US);
     }

     @Override
     public void tearDown() throws Exception {
         Locale.setDefault(defaultLocale);
         super.tearDown();
     }

     // Documented a previous difference in behavior between this and the RI, see
     // https://code.google.com/p/android/issues/detail?id=61993 for more details.
     // Switching to OpenJDK has fixed that issue and so this test has been changed to reflect
     // the correct behavior.
     public void test_computeFields_dayOfWeekAndWeekOfYearSet() {
         Calendar greg = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);

         // Ensure we use different values to the default ones.
         int differentWeekOfYear = greg.get(Calendar.WEEK_OF_YEAR) == 1 ? 2 : 1;
         int differentDayOfWeek = greg.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY
                 ? Calendar.TUESDAY : Calendar.MONDAY;

         // Setting WEEK_OF_YEAR and DAY_OF_WEEK with an intervening
         // call to computeFields will work.
         greg.set(Calendar.WEEK_OF_YEAR, differentWeekOfYear);
         assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));
         greg.set(Calendar.DAY_OF_WEEK, differentDayOfWeek);
         assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));

         // Setting WEEK_OF_YEAR after DAY_OF_WEEK with no intervening
         // call to computeFields will work.
         greg = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);
         greg.set(Calendar.DAY_OF_WEEK, differentDayOfWeek);
         greg.set(Calendar.WEEK_OF_YEAR, differentWeekOfYear);
         assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));
         assertEquals(differentDayOfWeek, greg.get(Calendar.DAY_OF_WEEK));

         // Setting DAY_OF_WEEK after WEEK_OF_YEAR with no intervening
         // call to computeFields will work.
         greg = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);
         greg.set(Calendar.WEEK_OF_YEAR, differentWeekOfYear);
         greg.set(Calendar.DAY_OF_WEEK, differentDayOfWeek);
         assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));
         assertEquals(differentDayOfWeek, greg.get(Calendar.DAY_OF_WEEK));
     }

     /**
      * Specialized tests for those fields affected by GregorianCalendar cut over date.
      *
      * <p>Expands on a regression test created for harmony-2947.
      */
     public void test_fieldsAffectedByGregorianCutOver() {

         Date date = new Date(Date.parse("Jan 1 00:00:01 GMT 2000"));
         assertEquals(946684801000L, date.getTime());

         GregorianCalendar gc;

         // Test in America/Los_Angeles
         gc = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);
         gc.setGregorianChange(date);
         gc.setTime(date);

         // Check the date to ensure that it is 18th Dec 1999. The reason this is not 1st Jan 2000
         // is that the offset for Los Angeles is GMT-08:00. setGregorianChange() is interpreted as
         // a wall time, not an instant. So, the instant that corresponds to
         // "1st Jan 2000 00:00:01 GMT" is 8 hours before the Julian/Gregorian switch in LA. The day
         // before 1st Jan 2000 (Gregorian Calendar) would be 18th Dec 1999 in the Julian calendar.
         // The reason it is not the 31st Dec 1999 is simply a result of the discontinuity that
         // occurred when switching calendars. That happened for real when the calendars were
         // switched in 1582.
         //
         // A different year explains why we get very different results for the methods being tested.
         assertEquals(1999, gc.get(Calendar.YEAR));
         assertEquals(Calendar.DECEMBER, gc.get(Calendar.MONTH));
         assertEquals(18, gc.get(Calendar.DAY_OF_MONTH));

         assertEquals(50, gc.getActualMaximum(Calendar.WEEK_OF_YEAR));
         assertEquals(50, gc.getLeastMaximum(Calendar.WEEK_OF_YEAR));
         assertEquals(3, gc.getActualMaximum(Calendar.WEEK_OF_MONTH));
         assertEquals(3, gc.getLeastMaximum(Calendar.WEEK_OF_MONTH));
         assertEquals(18, gc.getActualMaximum(Calendar.DAY_OF_MONTH));
         assertEquals(18, gc.getLeastMaximum(Calendar.DAY_OF_MONTH));
         assertEquals(352, gc.getActualMaximum(Calendar.DAY_OF_YEAR));
         assertEquals(352, gc.getLeastMaximum(Calendar.DAY_OF_YEAR));
         assertEquals(3, gc.getActualMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));
         assertEquals(3, gc.getLeastMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));

         // Test in Europe/London
         gc = new GregorianCalendar(LONDON, Locale.ENGLISH);
         gc.setGregorianChange(date);
         gc.setTime(date);

         // Check the date is actually 1st Jan 2000.
         assertEquals(2000, gc.get(Calendar.YEAR));
         assertEquals(Calendar.JANUARY, gc.get(Calendar.MONTH));
         assertEquals(1, gc.get(Calendar.DAY_OF_MONTH));

         assertEquals(53, gc.getActualMaximum(Calendar.WEEK_OF_YEAR));
         assertEquals(52, gc.getLeastMaximum(Calendar.WEEK_OF_YEAR));
         assertEquals(5, gc.getActualMaximum(Calendar.WEEK_OF_MONTH));
         assertEquals(4, gc.getLeastMaximum(Calendar.WEEK_OF_MONTH));
         assertEquals(31, gc.getActualMaximum(Calendar.DAY_OF_MONTH));
         assertEquals(28, gc.getLeastMaximum(Calendar.DAY_OF_MONTH));
         assertEquals(366, gc.getActualMaximum(Calendar.DAY_OF_YEAR));
         assertEquals(365, gc.getLeastMaximum(Calendar.DAY_OF_YEAR));
         assertEquals(5, gc.getActualMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));
         assertEquals(4, gc.getLeastMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));
     }

     public void test_computeTime_enteringDst_TimeZone_LosAngeles_2014() {
         TimeZone timeZone = TimeZone.getTimeZone("America/Los_Angeles");
         checkDstLosAngeles2014(timeZone);
     }

     /**
      * This test will fail in the RI.
      *
      * <p>The AOSP behavior is different for backwards compatibility with previous versions of
      * Android.
      *
      * <p>Search in this file for 'OpenJDK Failure' to see more details.
      */
     public void test_computeTime_enteringDst_DelegatingTimeZone_LosAngeles_2014() {
         TimeZone timeZone = TimeZone.getTimeZone("America/Los_Angeles");
         timeZone = new DelegatingTimeZone(timeZone);
         checkDstLosAngeles2014(timeZone);
     }

     /**
      * This test will fail in the RI.
      *
      * <p>The AOSP behavior is different for backwards compatibility with previous versions of
      * Android.
      *
      * <p>Search in this file for 'OpenJDK Failure' to see more details.
      */
     public void test_computeTime_enteringDst_SimpleTimeZone_LosAngeles_2014() {
         checkDstLosAngeles2014(CUSTOM_LOS_ANGELES_TIME_ZONE);
     }

     public void test_computeTime_enteringDst() {
         // Get the DST entry time with a ZoneInfo implementation of TimeZone.
         TimeZone zoneInfo = TimeZone.getTimeZone("America/Los_Angeles");
         long zoneInfoTime = getDstLosAngeles2014(zoneInfo);

         // Check that the time is correct.
         assertTrue(zoneInfo.inDaylightTime(new Date(zoneInfoTime)));
         assertFalse(zoneInfo.inDaylightTime(new Date(zoneInfoTime - 1)));

         // Get the DST entry time with a SimpleTimeZone implementation of TimeZone.
         SimpleTimeZone simpleTimeZone = new SimpleTimeZone(-28800000,
                 "Custom America/Los_Angeles",
                 Calendar.MARCH, 9, 0, 7200000,
                 Calendar.NOVEMBER, 2, 0, 7200000,
                 3600000);
         long simpleTimeZoneTime = getDstLosAngeles2014(simpleTimeZone);

     }

     public void test_isWeekDateSupported() {
         assertTrue(new GregorianCalendar().isWeekDateSupported());
     }

     public void test_setWeekDate() {
         GregorianCalendar cal = new GregorianCalendar();

         // When first week should have at least 4 days
         cal.setMinimalDaysInFirstWeek(4);
         cal.setWeekDate(2016, 13, Calendar.TUESDAY);
         assertEquals(Calendar.TUESDAY, cal.get(Calendar.DAY_OF_WEEK));
         assertEquals(29, cal.get(Calendar.DAY_OF_MONTH));

         // When first week can have single day
         cal.setMinimalDaysInFirstWeek(1);
         cal.setWeekDate(2016, 13, Calendar.TUESDAY);
         assertEquals(Calendar.TUESDAY, cal.get(Calendar.DAY_OF_WEEK));
         assertEquals(22, cal.get(Calendar.DAY_OF_MONTH));

         try {
             cal.setWeekDate(2016, 13, Calendar.SATURDAY + 1);
             fail();
         } catch (IllegalArgumentException expected) {
         }

         try {
             cal.setWeekDate(2016, 13, Calendar.SUNDAY - 1);
             fail();
         } catch (IllegalArgumentException expected) {
         }

         // in non-lenient mode
         cal.setLenient(false);
         try {
             cal.setWeekDate(2016, 60, Calendar.SATURDAY);
             fail();
         } catch (IllegalArgumentException expected) {}

         try {
             cal.setWeekDate(-1, 60, Calendar.SATURDAY);
             fail();
         } catch (IllegalArgumentException expected) {}
     }

     public void test_getWeekYear() {
         GregorianCalendar cal = new GregorianCalendar();

         cal.set(2016, Calendar.MARCH, 29);
         assertEquals(2016, cal.getWeekYear());

         // With minimal days in first week is set to 4
         cal.setMinimalDaysInFirstWeek(4);
         cal.set(2016, Calendar.JANUARY, 1);
         assertEquals(2015, cal.getWeekYear());
         cal.set(2015, Calendar.DECEMBER, 31);
         assertEquals(2015, cal.getWeekYear());

         // With minimal days in first week is set to 1
         cal.setMinimalDaysInFirstWeek(1);
         cal.set(2016, Calendar.JANUARY, 1);
         assertEquals(2016, cal.getWeekYear());
         cal.set(2015, Calendar.DECEMBER, 31);
         assertEquals(2016, cal.getWeekYear());
     }

     public void test_getWeeksInWeekYear() {
         GregorianCalendar cal = new GregorianCalendar();

         // With minimal days in first week is set to 1
         cal.setMinimalDaysInFirstWeek(1);
         cal.set(2016, Calendar.JANUARY, 10);
         assertEquals(53, cal.getWeeksInWeekYear());

         // With minimal days in first week is set to 4
         cal.setMinimalDaysInFirstWeek(4);
         cal.set(2016, Calendar.JANUARY, 10);
         assertEquals(52, cal.getWeeksInWeekYear());
     }

     public void test_fromZonedDateTime() {
         ZonedDateTime zdt = ZonedDateTime.parse("2007-12-03T10:15:30+01:00[Europe/Paris]");
         GregorianCalendar calendar = GregorianCalendar.from(zdt);
         TimeZone timeZone = TimeZone.getTimeZone("Europe/Paris");
         assertEquals(timeZone, calendar.getTimeZone());
         assertEquals(2007, calendar.get(Calendar.YEAR));
         assertEquals(Calendar.DECEMBER, calendar.get(Calendar.MONTH));
         assertEquals(3, calendar.get(Calendar.DAY_OF_MONTH));
         assertEquals(10, calendar.get(Calendar.HOUR_OF_DAY));
         assertEquals(15, calendar.get(Calendar.MINUTE));
         assertEquals(3600 * 1000, calendar.getTimeZone().getRawOffset()); // in milliseconds
     }

     public void test_fromZonedDateTime_invalidValues() {
         ZoneId gmt = ZoneId.of("GMT");
         ZonedDateTime[] invalidValues = {
                 ZonedDateTime.of(LocalDateTime.MAX, gmt),
                 ZonedDateTime.ofInstant(Instant.ofEpochMilli(Long.MAX_VALUE).plusMillis(1), gmt),
                 ZonedDateTime.ofInstant(Instant.ofEpochMilli(Long.MIN_VALUE).minusMillis(1), gmt),
                 ZonedDateTime.of(LocalDateTime.MAX, gmt) };
         for (ZonedDateTime invalidValue : invalidValues) {
             try {
                 GregorianCalendar.from(invalidValue);
                 fail("GregorianCalendar.from() should have failed with " + invalidValue);
             } catch (IllegalArgumentException expected) {}
         }
     }

     public void test_toZonedDateTime() {
         TimeZone timeZone = TimeZone.getTimeZone("Europe/Paris");
         GregorianCalendar calendar = new GregorianCalendar(timeZone);
         calendar.set(2007, Calendar.DECEMBER, 3, 10, 15, 30);
         calendar.set(Calendar.MILLISECOND, 0);
         ZonedDateTime zdt = calendar.toZonedDateTime();
         assertEquals(ZonedDateTime.parse("2007-12-03T10:15:30+01:00[Europe/Paris]"), zdt);
     }

     private long getDstLosAngeles2014(TimeZone timeZone) {
         GregorianCalendar cal = new GregorianCalendar(timeZone, Locale.ENGLISH);
         cal.set(Calendar.MILLISECOND, 0);
         cal.set(2014, Calendar.MARCH, 9, 2, 0, 0);

         return cal.getTimeInMillis();
     }

     private void checkDstLosAngeles2014(TimeZone timeZone) {
         Calendar cal = new GregorianCalendar(timeZone, Locale.ENGLISH);
         // Clear the milliseconds field.
         cal.set(Calendar.MILLISECOND, 0);

         String description;

         // Check milliseconds one second before the transition.
         description = "01:59:59 - March 9th 2014";
         cal.set(2014, Calendar.MARCH, 9, 1, 59, 59);
         checkMillis(cal, description, 1394359199000L);

         // Outside DST time.
         checkOutsideDst(cal, description);

         // Check milliseconds at the transition point but using an invalid wall clock
         // (02:00 - 02:59:59.999) do not actually exist.
         description = "02:00:00 - March 9th 2014";
         cal.set(2014, Calendar.MARCH, 9, 2, 0, 0);

         // OpenJDK Failure:
         //   This fails on OpenJDK when running with SimpleTimeZone (or any custom TimeZone
         //   implementation). It incorrectly calculates the time in millis to be 1394355600000.
         //   That is because GregorianCalendar treats the implementation that underpins
         //   TimeZone.getTimeZone(String) specially and the code that runs for other classes does
         //   not handle the invalid wall clock period on entry to DST properly.
         checkMillis(cal, description, 1394359200000L);

         // Invalid wall clock but treated as being inside DST time.
         checkInsideDst(cal, description);

         // Check milliseconds at the first valid wall clock time after transition, 03:00 - should
         // be treated the same as 02:00.
         description = "03:00:00 - March 9th 2014";
         cal.set(2014, Calendar.MARCH, 9, 3, 0, 0);
         checkMillis(cal, description, 1394359200000L);

         // Valid wall clock treated as being inside DST time.
         checkInsideDst(cal, description);

         // Check milliseconds at the last invalid wall clock time, 02:59:59.999.
         description = "02:59:59.999 - March 9th 2014";
         cal.set(2014, Calendar.MARCH, 9, 2, 59, 59);
         cal.set(Calendar.MILLISECOND, 999);
         checkMillis(cal, description, 1394362799999L);

         // Invalid wall clock but treated as being inside DST time.
         checkInsideDst(cal, description);

         // Check milliseconds at 03:59:59.999 - should be treated the same as 02:59:59.999
         description = "03:59:59.999 - March 9th 2014";
         cal.set(2014, Calendar.MARCH, 9, 3, 59, 59);
         cal.set(Calendar.MILLISECOND, 999);
         checkMillis(cal, description, 1394362799999L);

         // Valid wall clock treated as being inside DST time.
         checkInsideDst(cal, description);
     }

     private void checkMillis(Calendar cal, String description, long expectedMillis) {
         assertEquals("Incorrect millis: " + description, expectedMillis, cal.getTimeInMillis());
     }

     private void checkOutsideDst(Calendar cal, String description) {
         TimeZone timeZone = cal.getTimeZone();
         checkOutsideDst(cal, description, timeZone.getRawOffset());
     }

     private void checkOutsideDst(Calendar cal, String description, int expectedZoneOffset) {
         checkDstFields(cal, description, expectedZoneOffset, 0);
     }

     private void checkInsideDst(Calendar cal, String description) {
         TimeZone timeZone = cal.getTimeZone();
         checkDstFields(cal, description, timeZone.getRawOffset(), timeZone.getDSTSavings());
     }

     private void checkDstFields(Calendar cal, String description, int expectedZoneOffset, int expectedDstOffset) {
         assertEquals("Incorrect ZONE_OFFSET: " + description, expectedZoneOffset, cal.get(Calendar.ZONE_OFFSET));
         assertEquals("Incorrect DST_OFFSET: " + description, expectedDstOffset, cal.get(Calendar.DST_OFFSET));
     }

     /**
      * A custom {@link TimeZone} implementation.
      *
      * <p>Used to show the behavior of {@link GregorianCalendar} when provided with a custom
      * implementation of {@link TimeZone}, i.e. one that is unknown to the runtime,
      */
     private static class DelegatingTimeZone extends TimeZone {

         private final TimeZone timeZone;

         public DelegatingTimeZone(TimeZone timeZone) {
             this.timeZone = timeZone;
         }

         @Override
         public int getOffset(int era, int year, int month, int day, int dayOfWeek,
                 int milliseconds) {
             return timeZone.getOffset(era, year, month, day, dayOfWeek, milliseconds);
         }

         @Override
         public int getOffset(long date) {
             return timeZone.getOffset(date);
         }

         @Override
         public void setRawOffset(int offsetMillis) {
             timeZone.setRawOffset(offsetMillis);
         }

         @Override
         public int getRawOffset() {
             return timeZone.getRawOffset();
         }

         @Override
         public String getID() {
             return timeZone.getID();
         }

         @Override
         public void setID(String ID) {
             timeZone.setID(ID);
         }

         @Override
         public String getDisplayName(boolean daylightTime, int style, Locale locale) {
             return timeZone.getDisplayName(daylightTime, style, locale);
         }

         @Override
         public int getDSTSavings() {
             return timeZone.getDSTSavings();
         }

         @Override
         public boolean useDaylightTime() {
             return timeZone.useDaylightTime();
         }

         @Override
         public boolean observesDaylightTime() {
             return timeZone.observesDaylightTime();
         }

         @Override
         public boolean inDaylightTime(Date date) {
             return timeZone.inDaylightTime(date);
         }

         @Override
         public boolean hasSameRules(TimeZone other) {
             return timeZone.hasSameRules(other);
         }
     }

     private static int hours(int count) {
         return HOUR_IN_MILLIS * count;
     }
 }
	/*
	* Copyright (C) 2013 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/

	package libcore.java.util;

	import java.time.Instant;
	import java.time.LocalDateTime;
	import java.time.ZoneId;
	import java.time.ZonedDateTime;
	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 junit.framework.TestCase;

	public class GregorianCalendarTest extends TestCase {

	private static final TimeZone LOS_ANGELES = TimeZone.getTimeZone("America/Los_Angeles");

	private static final TimeZone LONDON = TimeZone.getTimeZone("Europe/London");

	private static final int HOUR_IN_MILLIS = 3600000;

	private static final SimpleTimeZone CUSTOM_LOS_ANGELES_TIME_ZONE = new SimpleTimeZone(-28800000,
	"Custom America/Los_Angeles",
	Calendar.MARCH, 9, 0, hours(2),
	Calendar.NOVEMBER, 2, 0, hours(2),
	hours(1));

	private Locale defaultLocale;

	@Override
	public void setUp() throws Exception {
	super.setUp();
	defaultLocale = Locale.getDefault();
	// Most tests are locale independent, but locale does affect start-of-week.
	Locale.setDefault(Locale.US);
	}

	@Override
	public void tearDown() throws Exception {
	Locale.setDefault(defaultLocale);
	super.tearDown();
	}

	// Documented a previous difference in behavior between this and the RI, see
	// https://code.google.com/p/android/issues/detail?id=61993 for more details.
	// Switching to OpenJDK has fixed that issue and so this test has been changed to reflect
	// the correct behavior.
	public void test_computeFields_dayOfWeekAndWeekOfYearSet() {
	Calendar greg = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);

	// Ensure we use different values to the default ones.
	int differentWeekOfYear = greg.get(Calendar.WEEK_OF_YEAR) == 1 ? 2 : 1;
	int differentDayOfWeek = greg.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY
	? Calendar.TUESDAY : Calendar.MONDAY;

	// Setting WEEK_OF_YEAR and DAY_OF_WEEK with an intervening
	// call to computeFields will work.
	greg.set(Calendar.WEEK_OF_YEAR, differentWeekOfYear);
	assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));
	greg.set(Calendar.DAY_OF_WEEK, differentDayOfWeek);
	assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));

	// Setting WEEK_OF_YEAR after DAY_OF_WEEK with no intervening
	// call to computeFields will work.
	greg = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);
	greg.set(Calendar.DAY_OF_WEEK, differentDayOfWeek);
	greg.set(Calendar.WEEK_OF_YEAR, differentWeekOfYear);
	assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));
	assertEquals(differentDayOfWeek, greg.get(Calendar.DAY_OF_WEEK));

	// Setting DAY_OF_WEEK after WEEK_OF_YEAR with no intervening
	// call to computeFields will work.
	greg = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);
	greg.set(Calendar.WEEK_OF_YEAR, differentWeekOfYear);
	greg.set(Calendar.DAY_OF_WEEK, differentDayOfWeek);
	assertEquals(differentWeekOfYear, greg.get(Calendar.WEEK_OF_YEAR));
	assertEquals(differentDayOfWeek, greg.get(Calendar.DAY_OF_WEEK));
	}

	/**
	* Specialized tests for those fields affected by GregorianCalendar cut over date.
	*
	* <p>Expands on a regression test created for harmony-2947.
	*/
	public void test_fieldsAffectedByGregorianCutOver() {

	Date date = new Date(Date.parse("Jan 1 00:00:01 GMT 2000"));
	assertEquals(946684801000L, date.getTime());

	GregorianCalendar gc;

	// Test in America/Los_Angeles
	gc = new GregorianCalendar(LOS_ANGELES, Locale.ENGLISH);
	gc.setGregorianChange(date);
	gc.setTime(date);

	// Check the date to ensure that it is 18th Dec 1999. The reason this is not 1st Jan 2000
	// is that the offset for Los Angeles is GMT-08:00. setGregorianChange() is interpreted as
	// a wall time, not an instant. So, the instant that corresponds to
	// "1st Jan 2000 00:00:01 GMT" is 8 hours before the Julian/Gregorian switch in LA. The day
	// before 1st Jan 2000 (Gregorian Calendar) would be 18th Dec 1999 in the Julian calendar.
	// The reason it is not the 31st Dec 1999 is simply a result of the discontinuity that
	// occurred when switching calendars. That happened for real when the calendars were
	// switched in 1582.
	//
	// A different year explains why we get very different results for the methods being tested.
	assertEquals(1999, gc.get(Calendar.YEAR));
	assertEquals(Calendar.DECEMBER, gc.get(Calendar.MONTH));
	assertEquals(18, gc.get(Calendar.DAY_OF_MONTH));

	assertEquals(50, gc.getActualMaximum(Calendar.WEEK_OF_YEAR));
	assertEquals(50, gc.getLeastMaximum(Calendar.WEEK_OF_YEAR));
	assertEquals(3, gc.getActualMaximum(Calendar.WEEK_OF_MONTH));
	assertEquals(3, gc.getLeastMaximum(Calendar.WEEK_OF_MONTH));
	assertEquals(18, gc.getActualMaximum(Calendar.DAY_OF_MONTH));
	assertEquals(18, gc.getLeastMaximum(Calendar.DAY_OF_MONTH));
	assertEquals(352, gc.getActualMaximum(Calendar.DAY_OF_YEAR));
	assertEquals(352, gc.getLeastMaximum(Calendar.DAY_OF_YEAR));
	assertEquals(3, gc.getActualMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));
	assertEquals(3, gc.getLeastMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));

	// Test in Europe/London
	gc = new GregorianCalendar(LONDON, Locale.ENGLISH);
	gc.setGregorianChange(date);
	gc.setTime(date);

	// Check the date is actually 1st Jan 2000.
	assertEquals(2000, gc.get(Calendar.YEAR));
	assertEquals(Calendar.JANUARY, gc.get(Calendar.MONTH));
	assertEquals(1, gc.get(Calendar.DAY_OF_MONTH));

	assertEquals(53, gc.getActualMaximum(Calendar.WEEK_OF_YEAR));
	assertEquals(52, gc.getLeastMaximum(Calendar.WEEK_OF_YEAR));
	assertEquals(5, gc.getActualMaximum(Calendar.WEEK_OF_MONTH));
	assertEquals(4, gc.getLeastMaximum(Calendar.WEEK_OF_MONTH));
	assertEquals(31, gc.getActualMaximum(Calendar.DAY_OF_MONTH));
	assertEquals(28, gc.getLeastMaximum(Calendar.DAY_OF_MONTH));
	assertEquals(366, gc.getActualMaximum(Calendar.DAY_OF_YEAR));
	assertEquals(365, gc.getLeastMaximum(Calendar.DAY_OF_YEAR));
	assertEquals(5, gc.getActualMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));
	assertEquals(4, gc.getLeastMaximum(Calendar.DAY_OF_WEEK_IN_MONTH));
	}

	public void test_computeTime_enteringDst_TimeZone_LosAngeles_2014() {
	TimeZone timeZone = TimeZone.getTimeZone("America/Los_Angeles");
	checkDstLosAngeles2014(timeZone);
	}

	/**
	* This test will fail in the RI.
	*
	* <p>The AOSP behavior is different for backwards compatibility with previous versions of
	* Android.
	*
	* <p>Search in this file for 'OpenJDK Failure' to see more details.
	*/
	public void test_computeTime_enteringDst_DelegatingTimeZone_LosAngeles_2014() {
	TimeZone timeZone = TimeZone.getTimeZone("America/Los_Angeles");
	timeZone = new DelegatingTimeZone(timeZone);
	checkDstLosAngeles2014(timeZone);
	}

	/**
	* This test will fail in the RI.
	*
	* <p>The AOSP behavior is different for backwards compatibility with previous versions of
	* Android.
	*
	* <p>Search in this file for 'OpenJDK Failure' to see more details.
	*/
	public void test_computeTime_enteringDst_SimpleTimeZone_LosAngeles_2014() {
	checkDstLosAngeles2014(CUSTOM_LOS_ANGELES_TIME_ZONE);
	}

	public void test_computeTime_enteringDst() {
	// Get the DST entry time with a ZoneInfo implementation of TimeZone.
	TimeZone zoneInfo = TimeZone.getTimeZone("America/Los_Angeles");
	long zoneInfoTime = getDstLosAngeles2014(zoneInfo);

	// Check that the time is correct.
	assertTrue(zoneInfo.inDaylightTime(new Date(zoneInfoTime)));
	assertFalse(zoneInfo.inDaylightTime(new Date(zoneInfoTime - 1)));

	// Get the DST entry time with a SimpleTimeZone implementation of TimeZone.
	SimpleTimeZone simpleTimeZone = new SimpleTimeZone(-28800000,
	"Custom America/Los_Angeles",
	Calendar.MARCH, 9, 0, 7200000,
	Calendar.NOVEMBER, 2, 0, 7200000,
	3600000);
	long simpleTimeZoneTime = getDstLosAngeles2014(simpleTimeZone);

	}

	public void test_isWeekDateSupported() {
	assertTrue(new GregorianCalendar().isWeekDateSupported());
	}

	public void test_setWeekDate() {
	GregorianCalendar cal = new GregorianCalendar();

	// When first week should have at least 4 days
	cal.setMinimalDaysInFirstWeek(4);
	cal.setWeekDate(2016, 13, Calendar.TUESDAY);
	assertEquals(Calendar.TUESDAY, cal.get(Calendar.DAY_OF_WEEK));
	assertEquals(29, cal.get(Calendar.DAY_OF_MONTH));

	// When first week can have single day
	cal.setMinimalDaysInFirstWeek(1);
	cal.setWeekDate(2016, 13, Calendar.TUESDAY);
	assertEquals(Calendar.TUESDAY, cal.get(Calendar.DAY_OF_WEEK));
	assertEquals(22, cal.get(Calendar.DAY_OF_MONTH));

	try {
	cal.setWeekDate(2016, 13, Calendar.SATURDAY + 1);
	fail();
	} catch (IllegalArgumentException expected) {
	}

	try {
	cal.setWeekDate(2016, 13, Calendar.SUNDAY - 1);
	fail();
	} catch (IllegalArgumentException expected) {
	}

	// in non-lenient mode
	cal.setLenient(false);
	try {
	cal.setWeekDate(2016, 60, Calendar.SATURDAY);
	fail();
	} catch (IllegalArgumentException expected) {}

	try {
	cal.setWeekDate(-1, 60, Calendar.SATURDAY);
	fail();
	} catch (IllegalArgumentException expected) {}
	}

	public void test_getWeekYear() {
	GregorianCalendar cal = new GregorianCalendar();

	cal.set(2016, Calendar.MARCH, 29);
	assertEquals(2016, cal.getWeekYear());

	// With minimal days in first week is set to 4
	cal.setMinimalDaysInFirstWeek(4);
	cal.set(2016, Calendar.JANUARY, 1);
	assertEquals(2015, cal.getWeekYear());
	cal.set(2015, Calendar.DECEMBER, 31);
	assertEquals(2015, cal.getWeekYear());

	// With minimal days in first week is set to 1
	cal.setMinimalDaysInFirstWeek(1);
	cal.set(2016, Calendar.JANUARY, 1);
	assertEquals(2016, cal.getWeekYear());
	cal.set(2015, Calendar.DECEMBER, 31);
	assertEquals(2016, cal.getWeekYear());
	}

	public void test_getWeeksInWeekYear() {
	GregorianCalendar cal = new GregorianCalendar();

	// With minimal days in first week is set to 1
	cal.setMinimalDaysInFirstWeek(1);
	cal.set(2016, Calendar.JANUARY, 10);
	assertEquals(53, cal.getWeeksInWeekYear());

	// With minimal days in first week is set to 4
	cal.setMinimalDaysInFirstWeek(4);
	cal.set(2016, Calendar.JANUARY, 10);
	assertEquals(52, cal.getWeeksInWeekYear());
	}

	public void test_fromZonedDateTime() {
	ZonedDateTime zdt = ZonedDateTime.parse("2007-12-03T10:15:30+01:00[Europe/Paris]");
	GregorianCalendar calendar = GregorianCalendar.from(zdt);
	TimeZone timeZone = TimeZone.getTimeZone("Europe/Paris");
	assertEquals(timeZone, calendar.getTimeZone());
	assertEquals(2007, calendar.get(Calendar.YEAR));
	assertEquals(Calendar.DECEMBER, calendar.get(Calendar.MONTH));
	assertEquals(3, calendar.get(Calendar.DAY_OF_MONTH));
	assertEquals(10, calendar.get(Calendar.HOUR_OF_DAY));
	assertEquals(15, calendar.get(Calendar.MINUTE));
	assertEquals(3600 * 1000, calendar.getTimeZone().getRawOffset()); // in milliseconds
	}

	public void test_fromZonedDateTime_invalidValues() {
	ZoneId gmt = ZoneId.of("GMT");
	ZonedDateTime[] invalidValues = {
	ZonedDateTime.of(LocalDateTime.MAX, gmt),
	ZonedDateTime.ofInstant(Instant.ofEpochMilli(Long.MAX_VALUE).plusMillis(1), gmt),
	ZonedDateTime.ofInstant(Instant.ofEpochMilli(Long.MIN_VALUE).minusMillis(1), gmt),
	ZonedDateTime.of(LocalDateTime.MAX, gmt) };
	for (ZonedDateTime invalidValue : invalidValues) {
	try {
	GregorianCalendar.from(invalidValue);
	fail("GregorianCalendar.from() should have failed with " + invalidValue);
	} catch (IllegalArgumentException expected) {}
	}
	}

	public void test_toZonedDateTime() {
	TimeZone timeZone = TimeZone.getTimeZone("Europe/Paris");
	GregorianCalendar calendar = new GregorianCalendar(timeZone);
	calendar.set(2007, Calendar.DECEMBER, 3, 10, 15, 30);
	calendar.set(Calendar.MILLISECOND, 0);
	ZonedDateTime zdt = calendar.toZonedDateTime();
	assertEquals(ZonedDateTime.parse("2007-12-03T10:15:30+01:00[Europe/Paris]"), zdt);
	}

	private long getDstLosAngeles2014(TimeZone timeZone) {
	GregorianCalendar cal = new GregorianCalendar(timeZone, Locale.ENGLISH);
	cal.set(Calendar.MILLISECOND, 0);
	cal.set(2014, Calendar.MARCH, 9, 2, 0, 0);

	return cal.getTimeInMillis();
	}

	private void checkDstLosAngeles2014(TimeZone timeZone) {
	Calendar cal = new GregorianCalendar(timeZone, Locale.ENGLISH);
	// Clear the milliseconds field.
	cal.set(Calendar.MILLISECOND, 0);

	String description;

	// Check milliseconds one second before the transition.
	description = "01:59:59 - March 9th 2014";
	cal.set(2014, Calendar.MARCH, 9, 1, 59, 59);
	checkMillis(cal, description, 1394359199000L);

	// Outside DST time.
	checkOutsideDst(cal, description);

	// Check milliseconds at the transition point but using an invalid wall clock
	// (02:00 - 02:59:59.999) do not actually exist.
	description = "02:00:00 - March 9th 2014";
	cal.set(2014, Calendar.MARCH, 9, 2, 0, 0);

	// OpenJDK Failure:
	// This fails on OpenJDK when running with SimpleTimeZone (or any custom TimeZone
	// implementation). It incorrectly calculates the time in millis to be 1394355600000.
	// That is because GregorianCalendar treats the implementation that underpins
	// TimeZone.getTimeZone(String) specially and the code that runs for other classes does
	// not handle the invalid wall clock period on entry to DST properly.
	checkMillis(cal, description, 1394359200000L);

	// Invalid wall clock but treated as being inside DST time.
	checkInsideDst(cal, description);

	// Check milliseconds at the first valid wall clock time after transition, 03:00 - should
	// be treated the same as 02:00.
	description = "03:00:00 - March 9th 2014";
	cal.set(2014, Calendar.MARCH, 9, 3, 0, 0);
	checkMillis(cal, description, 1394359200000L);

	// Valid wall clock treated as being inside DST time.
	checkInsideDst(cal, description);

	// Check milliseconds at the last invalid wall clock time, 02:59:59.999.
	description = "02:59:59.999 - March 9th 2014";
	cal.set(2014, Calendar.MARCH, 9, 2, 59, 59);
	cal.set(Calendar.MILLISECOND, 999);
	checkMillis(cal, description, 1394362799999L);

	// Invalid wall clock but treated as being inside DST time.
	checkInsideDst(cal, description);

	// Check milliseconds at 03:59:59.999 - should be treated the same as 02:59:59.999
	description = "03:59:59.999 - March 9th 2014";
	cal.set(2014, Calendar.MARCH, 9, 3, 59, 59);
	cal.set(Calendar.MILLISECOND, 999);
	checkMillis(cal, description, 1394362799999L);

	// Valid wall clock treated as being inside DST time.
	checkInsideDst(cal, description);
	}

	private void checkMillis(Calendar cal, String description, long expectedMillis) {
	assertEquals("Incorrect millis: " + description, expectedMillis, cal.getTimeInMillis());
	}

	private void checkOutsideDst(Calendar cal, String description) {
	TimeZone timeZone = cal.getTimeZone();
	checkOutsideDst(cal, description, timeZone.getRawOffset());
	}

	private void checkOutsideDst(Calendar cal, String description, int expectedZoneOffset) {
	checkDstFields(cal, description, expectedZoneOffset, 0);
	}

	private void checkInsideDst(Calendar cal, String description) {
	TimeZone timeZone = cal.getTimeZone();
	checkDstFields(cal, description, timeZone.getRawOffset(), timeZone.getDSTSavings());
	}

	private void checkDstFields(Calendar cal, String description, int expectedZoneOffset, int expectedDstOffset) {
	assertEquals("Incorrect ZONE_OFFSET: " + description, expectedZoneOffset, cal.get(Calendar.ZONE_OFFSET));
	assertEquals("Incorrect DST_OFFSET: " + description, expectedDstOffset, cal.get(Calendar.DST_OFFSET));
	}

	/**
	* A custom {@link TimeZone} implementation.
	*
	* <p>Used to show the behavior of {@link GregorianCalendar} when provided with a custom
	* implementation of {@link TimeZone}, i.e. one that is unknown to the runtime,
	*/
	private static class DelegatingTimeZone extends TimeZone {

	private final TimeZone timeZone;

	public DelegatingTimeZone(TimeZone timeZone) {
	this.timeZone = timeZone;
	}

	@Override
	public int getOffset(int era, int year, int month, int day, int dayOfWeek,
	int milliseconds) {
	return timeZone.getOffset(era, year, month, day, dayOfWeek, milliseconds);
	}

	@Override
	public int getOffset(long date) {
	return timeZone.getOffset(date);
	}

	@Override
	public void setRawOffset(int offsetMillis) {
	timeZone.setRawOffset(offsetMillis);
	}

	@Override
	public int getRawOffset() {
	return timeZone.getRawOffset();
	}

	@Override
	public String getID() {
	return timeZone.getID();
	}

	@Override
	public void setID(String ID) {
	timeZone.setID(ID);
	}

	@Override
	public String getDisplayName(boolean daylightTime, int style, Locale locale) {
	return timeZone.getDisplayName(daylightTime, style, locale);
	}

	@Override
	public int getDSTSavings() {
	return timeZone.getDSTSavings();
	}

	@Override
	public boolean useDaylightTime() {
	return timeZone.useDaylightTime();
	}

	@Override
	public boolean observesDaylightTime() {
	return timeZone.observesDaylightTime();
	}

	@Override
	public boolean inDaylightTime(Date date) {
	return timeZone.inDaylightTime(date);
	}

	@Override
	public boolean hasSameRules(TimeZone other) {
	return timeZone.hasSameRules(other);
	}
	}

	private static int hours(int count) {
	return HOUR_IN_MILLIS * count;
	}
	}