| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * 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.libcore.util; |
| |
| import junit.framework.TestCase; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.ObjectInputStream; |
| import java.nio.ByteBuffer; |
| import java.time.Duration; |
| import java.time.Instant; |
| import java.util.Arrays; |
| import java.util.Date; |
| import libcore.io.BufferIterator; |
| import libcore.timezone.ZoneInfoDb; |
| import libcore.timezone.testing.ZoneInfoTestHelper; |
| import libcore.util.ZoneInfo; |
| |
| /** |
| * Tests for {@link ZoneInfo} |
| */ |
| public class ZoneInfoTest extends TestCase { |
| |
| /** |
| * Checks that a {@link ZoneInfo} cannot be created without any types. |
| */ |
| public void testMakeTimeZone_NoTypes() throws Exception { |
| long[][] transitions = {}; |
| int[][] types = {}; |
| try { |
| createZoneInfo(transitions, types); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| /** |
| * Checks that a {@link ZoneInfo} can be created with one type and no transitions. |
| */ |
| public void testMakeTimeZone_OneType_NoTransitions() throws Exception { |
| long[][] transitions = {}; |
| int[][] types = { |
| { 4800, 0 } |
| }; |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types); |
| |
| // If there are no transitions then the offset should be constant irrespective of the time. |
| Instant[] times = { |
| Instant.ofEpochMilli(Long.MIN_VALUE), |
| Instant.ofEpochMilli(0), |
| Instant.ofEpochMilli(Long.MAX_VALUE), |
| }; |
| assertOffsetAt(zoneInfo, offsetFromSeconds(4800), times); |
| |
| // No transitions means no DST. |
| assertFalse("Doesn't use DST", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| |
| // The raw offset should be the offset of the first type. |
| assertRawOffset(zoneInfo, offsetFromSeconds(4800)); |
| } |
| |
| /** |
| * Checks that a {@link ZoneInfo} can be created with one non-DST transition. |
| */ |
| public void testReadTimeZone_OneNonDstTransition() throws Exception { |
| long[][] transitions = { |
| { 0, 0 } |
| }; |
| int[][] types = { |
| { 3600, 0 } |
| }; |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types); |
| |
| // Any time before the first transition is assumed to use the first standard transition. |
| Instant[] times = { timeFromSeconds(-2), timeFromSeconds(0), timeFromSeconds(2) }; |
| assertOffsetAt(zoneInfo, offsetFromSeconds(3600), times); |
| |
| // No transitions means no DST. |
| assertFalse("Doesn't use DST", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| |
| // The raw offset should be the offset of the first type. |
| assertRawOffset(zoneInfo, offsetFromSeconds(3600)); |
| } |
| |
| /** |
| * Checks that a {@link ZoneInfo} cannot be created with one DST but no non-DSTs transitions. |
| */ |
| public void testReadTimeZone_OneDstTransition() throws Exception { |
| long[][] transitions = { |
| { 0, 0 } |
| }; |
| int[][] types = { |
| { 3600, 1 } |
| }; |
| try { |
| createZoneInfo(transitions, types); |
| fail("Did not detect no non-DST transitions"); |
| } catch (IllegalStateException expected) { |
| } |
| } |
| |
| /** |
| * Checks to make sure that rounding the time from milliseconds to seconds does not cause issues |
| * around the boundary of negative transitions. |
| */ |
| public void testReadTimeZone_NegativeTransition() throws Exception { |
| long[][] transitions = { |
| { -2000, 0 }, |
| { -5, 1 }, |
| { 0, 2 }, |
| }; |
| int[][] types = { |
| { 1800, 0 }, |
| { 3600, 1 }, |
| { 5400, 0 } |
| }; |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types); |
| Instant transitionTime = timeFromSeconds(-5); |
| |
| // Even a millisecond before a transition means that the transition is not active. |
| Instant beforeTransitionTime = transitionTime.minusMillis(1); |
| assertOffsetAt(zoneInfo, offsetFromSeconds(1800), beforeTransitionTime); |
| assertInDaylightTime(zoneInfo, beforeTransitionTime, false); |
| |
| // A time equal to the transition point activates the transition. |
| assertOffsetAt(zoneInfo, offsetFromSeconds(3600), transitionTime); |
| assertInDaylightTime(zoneInfo, transitionTime, true); |
| |
| // A time after the transition point but before the next activates the transition. |
| Instant afterTransitionTime = transitionTime.plusMillis(1); |
| assertOffsetAt(zoneInfo, offsetFromSeconds(3600), afterTransitionTime); |
| assertInDaylightTime(zoneInfo, afterTransitionTime, true); |
| |
| assertFalse("Doesn't use DST", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| assertRawOffset(zoneInfo, offsetFromSeconds(5400)); |
| } |
| |
| /** |
| * Checks to make sure that rounding the time from milliseconds to seconds does not cause issues |
| * around the boundary of positive transitions. |
| */ |
| public void testReadTimeZone_PositiveTransition() throws Exception { |
| long[][] transitions = { |
| { 0, 0 }, |
| { 5, 1 }, |
| { 2000, 2 }, |
| }; |
| int[][] types = { |
| { 1800, 0 }, |
| { 3600, 1 }, |
| { 5400, 0 } |
| }; |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types); |
| |
| Instant transitionTime = timeFromSeconds(5); |
| |
| // Even a millisecond before a transition means that the transition is not active. |
| Instant beforeTransitionTime = transitionTime.minusMillis(1); |
| assertOffsetAt(zoneInfo, offsetFromSeconds(1800), beforeTransitionTime); |
| assertInDaylightTime(zoneInfo, beforeTransitionTime, false); |
| |
| // A time equal to the transition point activates the transition. |
| assertOffsetAt(zoneInfo, offsetFromSeconds(3600), transitionTime); |
| assertInDaylightTime(zoneInfo, transitionTime, true); |
| |
| // A time after the transition point but before the next activates the transition. |
| Instant afterTransitionTime = transitionTime.plusMillis(1); |
| assertOffsetAt(zoneInfo, offsetFromSeconds(3600), afterTransitionTime); |
| assertInDaylightTime(zoneInfo, afterTransitionTime, true); |
| |
| assertFalse("Doesn't use DST", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| assertRawOffset(zoneInfo, offsetFromSeconds(5400)); |
| } |
| |
| /** |
| * Checks that creating a {@link ZoneInfo} with future DST transitions but no past DST |
| * transitions where the transition times are negative is not affected by rounding issues. |
| */ |
| public void testReadTimeZone_HasFutureDST_NoPastDST_NegativeTransitions() throws Exception { |
| long[][] transitions = { |
| { -2000, 0 }, |
| { -500, 1 }, |
| { -100, 2 }, |
| }; |
| int[][] types = { |
| { 1800, 0 }, |
| { 3600, 0 }, |
| { 5400, 1 } |
| }; |
| // The expected DST savings is the difference between the DST offset (which includes the |
| // raw offset) and the preceding non-DST offset (which should just be the raw offset). |
| // Or in other words (5400 - 3600) * 1000 |
| Duration expectedDSTSavings = offsetFromSeconds(5400 - 3600); |
| |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(-700)); |
| |
| assertTrue("Should use DST but doesn't", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, expectedDSTSavings); |
| |
| // Now create one a few milliseconds before the DST transition to make sure that rounding |
| // errors don't cause a problem. |
| zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(-100).minusMillis(5)); |
| |
| assertTrue("Should use DST but doesn't", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, expectedDSTSavings); |
| } |
| |
| /** |
| * Checks that creating a {@link ZoneInfo} with future DST transitions but no past DST |
| * transitions where the transition times are positive is not affected by rounding issues. |
| */ |
| public void testReadTimeZone_HasFutureDST_NoPastDST_PositiveTransitions() throws Exception { |
| long[][] transitions = { |
| { 4000, 0 }, |
| { 5500, 1 }, |
| { 6000, 2 }, |
| }; |
| int[][] types = { |
| { 1800, 0 }, |
| { 3600, 0 }, |
| { 7200, 1 } |
| }; |
| // The expected DST savings is the difference between the DST offset (which includes the |
| // raw offset) and the preceding non-DST offset (which should just be the raw offset). |
| // Or in other words (7200 - 3600) * 1000 |
| Duration expectedDSTSavings = offsetFromSeconds(7200 - 3600); |
| |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(4500) /* currentTime */); |
| |
| assertTrue("Should use DST but doesn't", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, expectedDSTSavings); |
| |
| // Now create one a few milliseconds before the DST transition to make sure that rounding |
| // errors don't cause a problem. |
| zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(6000).minusMillis(5)); |
| |
| assertTrue("Should use DST but doesn't", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, expectedDSTSavings); |
| } |
| |
| /** |
| * Checks that creating a {@link ZoneInfo} with past DST transitions but no future DST |
| * transitions where the transition times are negative is not affected by rounding issues. |
| */ |
| public void testReadTimeZone_HasPastDST_NoFutureDST_NegativeTransitions() throws Exception { |
| long[][] transitions = { |
| { -5000, 0 }, |
| { -2000, 1 }, |
| { -500, 0 }, |
| { 0, 2 }, |
| }; |
| int[][] types = { |
| { 3600, 0 }, |
| { 1800, 1 }, |
| { 5400, 0 } |
| }; |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(-1) /* currentTime */); |
| |
| assertFalse("Shouldn't use DST but does", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| |
| // Now create one a few milliseconds after the DST transition to make sure that rounding |
| // errors don't cause a problem. |
| zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(-2000).plusMillis(5)); |
| |
| assertFalse("Shouldn't use DST but does", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| } |
| |
| /** |
| * Checks that creating a {@link ZoneInfo} with past DST transitions but no future DST |
| * transitions where the transition times are positive is not affected by rounding issues. |
| */ |
| public void testReadTimeZone_HasPastDST_NoFutureDST_PositiveTransitions() throws Exception { |
| long[][] transitions = { |
| { 1000, 0 }, |
| { 4000, 1 }, |
| { 5500, 0 }, |
| { 6000, 2 }, |
| }; |
| int[][] types = { |
| { 3600, 0 }, |
| { 1800, 1 }, |
| { 5400, 0 } |
| }; |
| ZoneInfo zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(4700)); |
| |
| assertFalse("Shouldn't use DST but does", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| |
| // Now create one a few milliseconds after the DST transition to make sure that rounding |
| // errors don't cause a problem. |
| zoneInfo = createZoneInfo(transitions, types, timeFromSeconds(4000).plusMillis(5)); |
| |
| assertFalse("Shouldn't use DST but does", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| } |
| |
| /** |
| * TimeZone APIs use Java long times in millis. |
| * |
| * <p>Android has historically mishandled the lookup of offset for times before Integer.MIN_VALUE |
| * seconds for various reasons. The logic has been corrected. This test would fail on versions of |
| * Android <= P. |
| */ |
| public void testReadTimeZone_Bug118835133_extraFirstTransition() throws Exception { |
| // A time before the first representable time in seconds with a java int. |
| Instant before32BitTime = timeFromSeconds(Integer.MIN_VALUE).minusMillis(1); |
| |
| // Times around the 32-bit seconds minimum. |
| Instant[] earlyTimes = { |
| timeFromSeconds(Integer.MIN_VALUE), |
| timeFromSeconds(Integer.MIN_VALUE).plusMillis(1), |
| }; |
| |
| Instant firstRealTransitionTime = timeFromSeconds(1000); |
| Instant afterFirstRealTransitionTime = firstRealTransitionTime.plusSeconds(1); |
| Instant[] afterFirstRealTransitionTimes = { |
| firstRealTransitionTime, |
| afterFirstRealTransitionTime, |
| }; |
| |
| // A time to use as currentTime when building the TimeZone. Important for the getRawOffset() |
| // calculation. |
| Instant currentTime = afterFirstRealTransitionTime; |
| |
| Duration type0Offset = offsetFromSeconds(0); |
| Duration type1Offset = offsetFromSeconds(1800); |
| Duration type2Offset = offsetFromSeconds(3600); |
| int[][] types = { |
| { offsetToSeconds(type0Offset), 0 }, // 1st type, used before first known transition. |
| { offsetToSeconds(type1Offset), 0 }, |
| { offsetToSeconds(type2Offset), 0 }, |
| }; |
| |
| // Simulates a zone with a single transition. |
| { |
| long[][] transitions = { |
| { timeToSeconds(firstRealTransitionTime), 2 /* type 2 */ }, |
| }; |
| ZoneInfo oldZoneInfo = createZoneInfo(transitions, types, currentTime); |
| assertRawOffset(oldZoneInfo, type2Offset); |
| |
| // We use the first non-DST type for times before the first transition. |
| assertOffsetAt(oldZoneInfo, type0Offset, before32BitTime); |
| assertOffsetAt(oldZoneInfo, type0Offset, earlyTimes); |
| |
| // This is after the first transition, so type 2. |
| assertOffsetAt(oldZoneInfo, type2Offset, afterFirstRealTransitionTimes); |
| } |
| |
| // Simulation a zone where there is an explicit transition at Integer.MIN_VALUE seconds. This |
| // used to be common when Android used 32-bit data from the TZif file. |
| { |
| long[][] transitions = { |
| { Integer.MIN_VALUE, 1 /* type 1 */ }, |
| { timeToSeconds(firstRealTransitionTime), 2 /* type 2 */ }, |
| }; |
| ZoneInfo newZoneInfo = createZoneInfo(transitions, types, currentTime); |
| assertRawOffset(newZoneInfo, type2Offset); |
| |
| // We use the first non-DST type for times before the first transition. |
| assertOffsetAt(newZoneInfo, type0Offset, before32BitTime); |
| |
| // After the first transition, so type 1. |
| assertOffsetAt(newZoneInfo, type1Offset, earlyTimes); |
| |
| // This is after the second transition, so type 2. |
| assertOffsetAt(newZoneInfo, type2Offset, afterFirstRealTransitionTimes); |
| } |
| } |
| |
| /** |
| * Newer versions of zic after 2014b sometime introduce an explicit transition at |
| * Integer.MAX_VALUE seconds. |
| */ |
| public void testReadTimeZone_Bug118835133_extraLastTransition() throws Exception { |
| // An arbitrary time to use as currentTime. Not important for this test. |
| Instant currentTime = timeFromSeconds(4000); |
| |
| // Offset before time 1000 should be consistent. |
| Instant[] timesToCheck = { |
| timeFromSeconds(2100), // arbitrary time > 2000 |
| timeFromSeconds(Integer.MAX_VALUE).minusMillis(1), |
| timeFromSeconds(Integer.MAX_VALUE), |
| timeFromSeconds(Integer.MAX_VALUE).plusMillis(1), |
| }; |
| |
| int latestOffsetSeconds = 3600; |
| int[][] types = { |
| { 1800, 0 }, |
| { latestOffsetSeconds, 0 }, |
| }; |
| Duration expectedLateOffset = offsetFromSeconds(latestOffsetSeconds); |
| |
| // Create a simulation of a zone where there is no explicit transition at Integer.MAX_VALUE |
| // seconds. |
| { |
| long[][] transitions = { |
| { 1000, 0 }, |
| { 2000, 1 }, |
| }; |
| ZoneInfo oldZoneInfo = createZoneInfo(transitions, types, currentTime); |
| assertOffsetAt(oldZoneInfo, expectedLateOffset, timesToCheck); |
| } |
| |
| // Create a simulation of a zone where there is an explicit transition at Integer.MAX_VALUE |
| // seconds. |
| { |
| long[][] transitions = { |
| { 1000, 0 }, |
| { 2000, 1 }, |
| { Integer.MAX_VALUE, 1}, // The extra transition. |
| }; |
| ZoneInfo newZoneInfo = createZoneInfo(transitions, types, currentTime); |
| assertOffsetAt(newZoneInfo, expectedLateOffset, timesToCheck); |
| } |
| } |
| |
| /** |
| * Checks to make sure that ZoneInfo can handle up to 256 types. |
| */ |
| public void testReadTimeZone_MaxTypeCount() throws Exception { |
| long[][] transitions = { |
| { -2000, 255 }, |
| }; |
| // Create 256 types, each with zero offset and without DST except the last, which is offset by |
| // one hour but also without DST. |
| int[][] types = new int[256][]; |
| Arrays.fill(types, new int[2]); |
| types[255] = new int[] { 3600, 0 }; |
| |
| ZoneInfo zoneInfo = createZoneInfo(getName(), transitions, types, |
| timeFromSeconds(Integer.MIN_VALUE)); |
| |
| assertFalse("Shouldn't use DST but does", zoneInfo.useDaylightTime()); |
| assertDSTSavings(zoneInfo, offsetFromSeconds(0)); |
| |
| // Make sure that WallTime works properly with a ZoneInfo with 256 types. |
| ZoneInfo.WallTime wallTime = new ZoneInfo.WallTime(); |
| wallTime.localtime(0, zoneInfo); |
| wallTime.mktime(zoneInfo); |
| } |
| |
| /** |
| * Create an instance for every available time zone for which we have data to ensure that they |
| * can all be handled correctly. |
| * |
| * <p>This is to ensure that ZoneInfo can read all time zone data without failing, it doesn't |
| * check that it reads it correctly or that the data itself is correct. This is a sanity test |
| * to ensure that any additional checks added to the code that reads the data source and |
| * creates the {@link ZoneInfo} instances does not prevent any of the time zones being loaded. |
| */ |
| public void testReadTimeZone_All() throws Exception { |
| ZoneInfoDb instance = ZoneInfoDb.getInstance(); |
| String[] availableIDs = instance.getAvailableIDs(); |
| Arrays.sort(availableIDs); |
| for (String id : availableIDs) { |
| BufferIterator bufferIterator = instance.getBufferIterator(id); |
| |
| // Create a ZoneInfo at the earliest possible time to allow us to use the |
| // useDaylightTime() method to check whether it ever has or ever will support daylight |
| // savings time. |
| ZoneInfo zoneInfo = ZoneInfo.readTimeZone(id, bufferIterator, Long.MIN_VALUE); |
| assertNotNull("TimeZone " + id + " was not created", zoneInfo); |
| assertEquals(id, zoneInfo.getID()); |
| } |
| } |
| |
| public void testReadTimeZone_Valid() throws Exception { |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid(); |
| assertNotNull(createZoneInfo(getName(), Instant.now(), builder.build())); |
| } |
| |
| public void testReadTimeZone_BadMagic() { |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid() |
| .setMagic(0xdeadbeef); // Bad magic. |
| try { |
| createZoneInfo(getName(), Instant.now(), builder.build()); |
| fail(); |
| } catch (IOException expected) {} |
| } |
| |
| /** |
| * Checks to make sure that ZoneInfo rejects more than 256 types. |
| */ |
| public void testReadTimeZone_TooManyTypes() { |
| int typeCount = 257; // Max types allowed is 256 |
| int transitionCount = 5; |
| long[][] transitions = createTransitions(transitionCount, typeCount); |
| int[][] types = createTypes(typeCount); |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid() |
| .setTransitionsAndTypes(transitions, types); |
| byte[] bytes = builder.build(); |
| try { |
| createZoneInfo(getName(), Instant.now(), bytes); |
| fail("Did not detect too many types"); |
| } catch (IOException expected) { |
| } |
| } |
| |
| /** |
| * Checks to make sure that ZoneInfo rejects more than 2000 transitions. |
| */ |
| public void testReadTimeZone_TooManyTransitions() { |
| int typeCount = 5; |
| int transitionCount = 2001; // Max transitions allowed is 2000. |
| long[][] transitions = createTransitions(transitionCount, typeCount); |
| int[][] types = createTypes(typeCount); |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid() |
| .setTransitionsAndTypes(transitions, types); |
| byte[] bytes = builder.build(); |
| try { |
| createZoneInfo(getName(), Instant.now(), bytes); |
| fail("Did not detect too many transitions"); |
| } catch (IOException expected) { |
| } |
| } |
| |
| public void testReadTimeZone_TransitionsNotSorted() { |
| long[][] transitions = { |
| { 1000, 0 }, |
| { 3000, 1 }, // Out of transition order. |
| { 2000, 0 }, |
| }; |
| int[][] types = { |
| { 3600, 0 }, |
| { 1800, 1 }, |
| }; |
| |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid() |
| .setTransitionsAndTypes(transitions, types); |
| |
| byte[] bytes = builder.build(); |
| try { |
| createZoneInfo(getName(), Instant.now(), bytes); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| public void testReadTimeZone_InvalidTypeIndex() { |
| long[][] transitions = { |
| { 1000, 0 }, |
| { 2000, 2 }, // Invalid type index - only 0 and 1 defined below. |
| { 3000, 0 }, |
| }; |
| int[][] types = { |
| { 3600, 0 }, |
| { 1800, 1 }, |
| }; |
| |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid() |
| .setTransitionsAndTypes(transitions, types); |
| |
| byte[] bytes = builder.build(); |
| try { |
| createZoneInfo(getName(), Instant.now(), bytes); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| public void testReadTimeZone_InvalidIsDst() { |
| long[][] transitions = { |
| { 1000, 0 }, |
| { 2000, 1 }, |
| { 3000, 0 }, |
| }; |
| int[][] types = { |
| { 3600, 0 }, |
| { 1800, 2 }, // Invalid isDst - must be 0 or 1 |
| }; |
| |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .initializeToValid() |
| .setTransitionsAndTypes(transitions, types); |
| |
| byte[] bytes = builder.build(); |
| try { |
| createZoneInfo(getName(), Instant.now(), bytes); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| /** |
| * Checks that we can read the serialized form of a {@link ZoneInfo} created in pre-OpenJDK |
| * AOSP. |
| * |
| * <p>One minor difference is that in pre-OpenJDK {@link ZoneInfo#mDstSavings} can be non-zero |
| * even if {@link ZoneInfo#mUseDst} was false. That was not visible externally (except through |
| * the {@link ZoneInfo#toString()} method) as the {@link ZoneInfo#getDSTSavings()} would check |
| * {@link ZoneInfo#mUseDst} and if it was false then would return 0. This checks to make sure |
| * that is handled properly. See {@link ZoneInfo#readObject(ObjectInputStream)}. |
| */ |
| public void testReadSerialized() throws Exception { |
| ZoneInfo zoneInfoRead; |
| try (InputStream is = getClass().getResourceAsStream("ZoneInfoTest_ZoneInfo.golden.ser"); |
| ObjectInputStream ois = new ObjectInputStream(is)) { |
| Object object = ois.readObject(); |
| assertTrue("Not a ZoneInfo instance", object instanceof ZoneInfo); |
| zoneInfoRead = (ZoneInfo) object; |
| } |
| |
| long[][] transitions = { |
| { -5000, 0 }, |
| { -2000, 1 }, |
| { -500, 0 }, |
| { 0, 2 }, |
| }; |
| int[][] types = { |
| { 3600, 0 }, |
| { 1800, 1 }, |
| { 5400, 0 } |
| }; |
| ZoneInfo zoneInfoCreated = createZoneInfo( |
| "test", transitions, types, timeFromSeconds(-1)); |
| |
| assertEquals("Read ZoneInfo does not match created one", zoneInfoCreated, zoneInfoRead); |
| assertEquals("useDaylightTime() mismatch", |
| zoneInfoCreated.useDaylightTime(), zoneInfoRead.useDaylightTime()); |
| assertEquals("getDSTSavings() mismatch", |
| zoneInfoCreated.getDSTSavings(), zoneInfoRead.getDSTSavings()); |
| } |
| |
| private static void assertRawOffset(ZoneInfo zoneInfo, Duration expectedOffset) { |
| assertEquals(expectedOffset.toMillis(), zoneInfo.getRawOffset()); |
| } |
| |
| private static void assertDSTSavings(ZoneInfo zoneInfo, Duration expectedDSTSavings) { |
| assertEquals(expectedDSTSavings.toMillis(), zoneInfo.getDSTSavings()); |
| } |
| |
| private static void assertInDaylightTime(ZoneInfo zoneInfo, Instant time, boolean expectedValue) { |
| assertEquals(expectedValue, zoneInfo.inDaylightTime(new Date(time.toEpochMilli()))); |
| } |
| |
| private static void assertOffsetAt( |
| ZoneInfo zoneInfo, Duration expectedOffset, Instant... times) { |
| for (Instant time : times) { |
| assertEquals("Unexpected offset at " + time, |
| expectedOffset.toMillis(), zoneInfo.getOffset(time.toEpochMilli())); |
| } |
| } |
| |
| private static Instant timeFromSeconds(long timeInSeconds) { |
| return Instant.ofEpochSecond(timeInSeconds); |
| } |
| |
| private static long timeToSeconds(Instant time) { |
| return time.getEpochSecond(); |
| } |
| |
| private static Duration offsetFromSeconds(int offsetSeconds) { |
| return Duration.ofSeconds(offsetSeconds); |
| } |
| |
| private static int offsetToSeconds(Duration offset) { |
| long seconds = offset.getSeconds(); |
| if (seconds < Integer.MIN_VALUE || seconds > Integer.MAX_VALUE) { |
| fail("Offset out of seconds range: " + offset); |
| } |
| return (int) seconds; |
| } |
| |
| private ZoneInfo createZoneInfo(long[][] transitions, int[][] types) |
| throws Exception { |
| return createZoneInfo(getName(), transitions, types, Instant.now()); |
| } |
| |
| private ZoneInfo createZoneInfo(long[][] transitions, int[][] types, Instant currentTime) |
| throws Exception { |
| return createZoneInfo(getName(), transitions, types, currentTime); |
| } |
| |
| private ZoneInfo createZoneInfo(String name, long[][] transitions, int[][] types, |
| Instant currentTime) throws Exception { |
| |
| ZoneInfoTestHelper.ZicDataBuilder builder = |
| new ZoneInfoTestHelper.ZicDataBuilder() |
| .setTransitionsAndTypes(transitions, types); |
| return createZoneInfo(name, currentTime, builder.build()); |
| } |
| |
| private static ZoneInfo createZoneInfo(String name, Instant currentTime, byte[] bytes) |
| throws IOException { |
| ByteBufferIterator bufferIterator = new ByteBufferIterator(ByteBuffer.wrap(bytes)); |
| return ZoneInfo.readTimeZone( |
| "TimeZone for '" + name + "'", bufferIterator, currentTime.toEpochMilli()); |
| } |
| |
| /** |
| * Creates {@code typeCount} "types" for use with |
| * {@link ZoneInfoTestHelper.ZicDataBuilder#setTypes(int[][])} and related methods. Each type is |
| * given an arbitrary offset and "isDst" value. |
| */ |
| private static int[][] createTypes(int typeCount) { |
| int[][] types = new int[typeCount][2]; |
| for (int i = 0; i < typeCount; i++) { |
| // [0] holds the offset from UTC in seconds. |
| types[i][0] = typeCount; |
| // [1] holds isDst: 0 == STD, 1 == DST |
| types[i][1] = typeCount % 2; |
| } |
| return types; |
| } |
| |
| /** |
| * Creates {@code transitionCount} "transition pairs" for use with |
| * {@link ZoneInfoTestHelper.ZicDataBuilder#setTransitions(long[][])} and related methods. Each |
| * transition is given an arbitrary (but increasing) time referencing an arbitrary type. |
| */ |
| private static long[][] createTransitions(int transitionCount, int typeCount) { |
| long[][] transitions = new long[transitionCount][2]; |
| for (int i = 0; i < transitionCount; i++) { |
| // [0] holds the transition time. |
| transitions[i][0] = (i * 3600) + 100; |
| // [1] holds the type index to use. Must be > 0 and < typeCount to be valid. |
| transitions[i][1] = i % typeCount; |
| } |
| return transitions; |
| } |
| |
| /** |
| * A {@link BufferIterator} that wraps a {@link ByteBuffer}. |
| */ |
| private static class ByteBufferIterator extends BufferIterator { |
| |
| private final ByteBuffer buffer; |
| |
| public ByteBufferIterator(ByteBuffer buffer) { |
| this.buffer = buffer; |
| } |
| |
| @Override |
| public void seek(int offset) { |
| buffer.position(offset); |
| } |
| |
| @Override |
| public void skip(int byteCount) { |
| buffer.position(buffer.position() + byteCount); |
| } |
| |
| @Override |
| public int pos() { |
| return buffer.position(); |
| } |
| |
| @Override |
| public void readByteArray(byte[] bytes, int arrayOffset, int byteCount) { |
| buffer.get(bytes, arrayOffset, byteCount); |
| } |
| |
| @Override |
| public byte readByte() { |
| return buffer.get(); |
| } |
| |
| @Override |
| public int readInt() { |
| int value = buffer.asIntBuffer().get(); |
| // Using a separate view does not update the position of this buffer so do it |
| // explicitly. |
| skip(Integer.BYTES); |
| return value; |
| } |
| |
| @Override |
| public void readIntArray(int[] ints, int arrayOffset, int intCount) { |
| buffer.asIntBuffer().get(ints, arrayOffset, intCount); |
| // Using a separate view does not update the position of this buffer so do it |
| // explicitly. |
| skip(Integer.BYTES * intCount); |
| } |
| |
| @Override |
| public void readLongArray(long[] longs, int arrayOffset, int longCount) { |
| buffer.asLongBuffer().get(longs, arrayOffset, longCount); |
| // Using a separate view does not update the position of this buffer so do it |
| // explicitly. |
| skip(Long.BYTES * longCount); |
| } |
| |
| @Override |
| public short readShort() { |
| short value = buffer.asShortBuffer().get(); |
| // Using a separate view does not update the position of this buffer so do it |
| // explicitly. |
| skip(Short.BYTES); |
| return value; |
| } |
| } |
| } |
