/*
 * Copyright (C) 2017 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.timezone;

import org.junit.Test;

import android.icu.util.TimeZone;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import libcore.timezone.CountryTimeZones;
import libcore.timezone.CountryTimeZones.OffsetResult;
import libcore.timezone.CountryTimeZones.TimeZoneMapping;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

public class CountryTimeZonesTest {

    private static final int HOUR_MILLIS = 60 * 60 * 1000;

    private static final String INVALID_TZ_ID = "Moon/Tranquility_Base";

    // Zones used in the tests. NY_TZ and LON_TZ chosen because they never overlap but both have
    // DST.
    private static final TimeZone NY_TZ = TimeZone.getTimeZone("America/New_York");
    private static final TimeZone LON_TZ = TimeZone.getTimeZone("Europe/London");
    // A zone that matches LON_TZ for WHEN_NO_DST. It does not have DST so differs for WHEN_DST.
    private static final TimeZone REYK_TZ = TimeZone.getTimeZone("Atlantic/Reykjavik");
    // Another zone that matches LON_TZ for WHEN_NO_DST. It does not have DST so differs for
    // WHEN_DST.
    private static final TimeZone UTC_TZ = TimeZone.getTimeZone("Etc/UTC");

    // 22nd July 2017, 13:14:15 UTC (DST time in all the timezones used in these tests that observe
    // DST).
    private static final long WHEN_DST = 1500729255000L;
    // 22nd January 2018, 13:14:15 UTC (non-DST time in all timezones used in these tests).
    private static final long WHEN_NO_DST = 1516626855000L;

    // The offset applied to most zones during DST.
    private static final int NORMAL_DST_ADJUSTMENT = HOUR_MILLIS;

    private static final int LON_NO_DST_TOTAL_OFFSET = 0;
    private static final int LON_DST_TOTAL_OFFSET = LON_NO_DST_TOTAL_OFFSET
            + NORMAL_DST_ADJUSTMENT;

    private static final int NY_NO_DST_TOTAL_OFFSET = -5 * HOUR_MILLIS;
    private static final int NY_DST_TOTAL_OFFSET = NY_NO_DST_TOTAL_OFFSET
            + NORMAL_DST_ADJUSTMENT;

    @Test
    public void createValidated() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", "Europe/London", false /* defaultTimeZoneBoost */,
                true /* everUsesUtc */, timeZoneMappings("Europe/London"), "test");
        assertTrue(countryTimeZones.isForCountryCode("gb"));
        assertEquals("Europe/London", countryTimeZones.getDefaultTimeZoneId());
        assertZoneEquals(zone("Europe/London"), countryTimeZones.getDefaultTimeZone());
        assertEquals(timeZoneMappings("Europe/London"), countryTimeZones.getTimeZoneMappings());
        assertEquals(timeZoneMappings("Europe/London"),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(0 /* whenMillis */));
    }

    @Test
    public void createValidated_nullDefault() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", null, false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London"), "test");
        assertNull(countryTimeZones.getDefaultTimeZoneId());
        assertNull(countryTimeZones.getDefaultTimeZone());
    }

    @Test
    public void createValidated_invalidDefault() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", INVALID_TZ_ID, false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London", INVALID_TZ_ID), "test");
        assertNull(countryTimeZones.getDefaultTimeZoneId());
        assertNull(countryTimeZones.getDefaultTimeZone());
        assertEquals(timeZoneMappings("Europe/London"), countryTimeZones.getTimeZoneMappings());
        assertEquals(timeZoneMappings("Europe/London"),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(0 /* whenMillis */));
    }

    @Test
    public void createValidated_unknownTimeZoneIdIgnored() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Unknown_Id", "Europe/London"), "test");
        assertEquals(timeZoneMappings("Europe/London"), countryTimeZones.getTimeZoneMappings());
        assertEquals(timeZoneMappings("Europe/London"),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(0 /* whenMillis */));
    }

    @Test
    public void isForCountryCode() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London"), "test");
        assertTrue(countryTimeZones.isForCountryCode("GB"));
        assertTrue(countryTimeZones.isForCountryCode("Gb"));
        assertTrue(countryTimeZones.isForCountryCode("gB"));
    }

    @Test
    public void structuresAreImmutable() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London"), "test");

        assertImmutableTimeZone(countryTimeZones.getDefaultTimeZone());

        List<TimeZoneMapping> timeZoneMappings = countryTimeZones.getTimeZoneMappings();
        assertEquals(1, timeZoneMappings.size());
        assertImmutableList(timeZoneMappings);

        List<TimeZoneMapping> effectiveTimeZoneMappings =
                countryTimeZones.getEffectiveTimeZoneMappingsAt(0 /* whenMillis */);
        assertEquals(1, effectiveTimeZoneMappings.size());
        assertImmutableList(effectiveTimeZoneMappings);
    }

    @Test
    public void lookupByOffsetWithBias_oneCandidate() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "gb", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London"), "test");

        OffsetResult lonMatch = new OffsetResult(LON_TZ, true /* oneMatch */);

        // Placeholder constants to improve test case readability.
        final Boolean isDst = true;
        final Boolean notDst = false;
        final Boolean unkIsDst = null;
        final TimeZone noBias = null;
        final OffsetResult noMatch = null;

        Object[][] testCases = new Object[][] {
                // totalOffsetMillis, isDst, whenMillis, bias, expectedMatch

                // The parameters match the zone: total offset and time.
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, noBias, lonMatch },
                { LON_NO_DST_TOTAL_OFFSET, unkIsDst, WHEN_NO_DST, noBias, lonMatch },

                // The parameters match the zone: total offset, isDst and time.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, noBias, lonMatch },
                { LON_NO_DST_TOTAL_OFFSET, notDst, WHEN_NO_DST, noBias, lonMatch },

                // Some lookup failure cases where the total offset, isDst and time do not match the
                // zone.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, noBias, noMatch },
                { LON_DST_TOTAL_OFFSET, notDst, WHEN_NO_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, isDst, WHEN_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, noBias, noMatch },
                { LON_DST_TOTAL_OFFSET, notDst, WHEN_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, notDst, WHEN_DST, noBias, noMatch },

                // Some bias cases below.

                // The bias is irrelevant here: it matches what would be returned anyway.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, LON_TZ, lonMatch },
                { LON_NO_DST_TOTAL_OFFSET, notDst, WHEN_NO_DST, LON_TZ, lonMatch },

                // A sample of a non-matching case with bias.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, LON_TZ, noMatch },

                // The bias should be ignored: it doesn't match any of the country's zones.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, NY_TZ, lonMatch },

                // The bias should still be ignored even though it matches the offset information
                // given it doesn't match any of the country's zones.
                { NY_DST_TOTAL_OFFSET, isDst, WHEN_DST, NY_TZ, noMatch },
        };
        executeLookupByOffsetWithBiasTestCases(countryTimeZones, testCases);
    }

    @Test
    public void lookupByOffsetWithBias_multipleNonOverlappingCandidates() throws Exception {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("America/New_York", "Europe/London"), "test");

        OffsetResult lonMatch = new OffsetResult(LON_TZ, true /* oneMatch */);
        OffsetResult nyMatch = new OffsetResult(NY_TZ, true /* oneMatch */);

        // Placeholder constants to improve test case readability.
        final Boolean isDst = true;
        final Boolean notDst = false;
        final Boolean unkIsDst = null;
        final TimeZone noBias = null;
        final OffsetResult noMatch = null;

        Object[][] testCases = new Object[][] {
                // totalOffsetMillis, isDst, dstOffsetMillis, whenMillis, bias, expectedMatch

                // The parameters match the zone: total offset and time.
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, noBias, lonMatch },
                { LON_NO_DST_TOTAL_OFFSET, unkIsDst, WHEN_NO_DST, noBias, lonMatch },
                { NY_NO_DST_TOTAL_OFFSET, unkIsDst, WHEN_NO_DST, noBias, nyMatch },
                { NY_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, noBias, nyMatch },

                // The parameters match the zone: total offset, isDst and time.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, noBias, lonMatch },
                { LON_NO_DST_TOTAL_OFFSET, notDst, WHEN_NO_DST, noBias, lonMatch },
                { NY_DST_TOTAL_OFFSET, isDst, WHEN_DST, noBias, nyMatch },
                { NY_NO_DST_TOTAL_OFFSET, notDst, WHEN_NO_DST, noBias, nyMatch },

                // Some lookup failure cases where the total offset, isDst and time do not match the
                // zone. This is a sample, not complete.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, noBias, noMatch },
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_NO_DST, noBias, noMatch },
                { LON_DST_TOTAL_OFFSET, notDst, WHEN_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, isDst, WHEN_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, noBias, noMatch },
                { LON_NO_DST_TOTAL_OFFSET, notDst, WHEN_DST, noBias, noMatch },

                // Some bias cases below.

                // The bias is irrelevant here: it matches what would be returned anyway.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, LON_TZ, lonMatch },
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, LON_TZ, lonMatch },
                { LON_NO_DST_TOTAL_OFFSET, unkIsDst, WHEN_NO_DST, LON_TZ, lonMatch },

                // A sample of non-matching cases with bias.
                { LON_NO_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, LON_TZ, noMatch },
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_NO_DST, LON_TZ, noMatch },
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_NO_DST, LON_TZ, noMatch },

                // The bias should be ignored: it matches a zone, but the offset is wrong so
                // should not be considered a match.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, NY_TZ, lonMatch },
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, NY_TZ, lonMatch },
        };
        executeLookupByOffsetWithBiasTestCases(countryTimeZones, testCases);
    }

    // This is an artificial case very similar to America/Denver and America/Phoenix in the US: both
    // have the same offset for 6 months of the year but diverge. Australia/Lord_Howe too.
    @Test
    public void lookupByOffsetWithBias_multipleOverlappingCandidates() throws Exception {
        // Three zones that have the same offset for some of the year. Europe/London changes
        // offset WHEN_DST, the others do not.
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Atlantic/Reykjavik", "Europe/London", "Etc/UTC"), "test");

        // Placeholder constants to improve test case readability.
        final Boolean isDst = true;
        final Boolean notDst = false;
        final Boolean unkIsDst = null;
        final TimeZone noBias = null;
        final OffsetResult noMatch = null;

        // This is the no-DST offset for LON_TZ, REYK_TZ. UTC_TZ.
        final int noDstTotalOffset = LON_NO_DST_TOTAL_OFFSET;
        // This is the DST offset for LON_TZ.
        final int dstTotalOffset = LON_DST_TOTAL_OFFSET;

        OffsetResult lonOnlyMatch = new OffsetResult(LON_TZ, true /* oneMatch */);
        OffsetResult lonBestMatch = new OffsetResult(LON_TZ, false /* oneMatch */);
        OffsetResult reykBestMatch = new OffsetResult(REYK_TZ, false /* oneMatch */);
        OffsetResult utcBestMatch = new OffsetResult(UTC_TZ, false /* oneMatch */);

        Object[][] testCases = new Object[][] {
                // totalOffsetMillis, isDst, dstOffsetMillis, whenMillis, bias, expectedMatch

                // The parameters match one zone: total offset and time.
                { dstTotalOffset, unkIsDst, WHEN_DST, noBias, lonOnlyMatch },
                { dstTotalOffset, unkIsDst, WHEN_DST, noBias, lonOnlyMatch },

                // The parameters match several zones: total offset and time.
                { noDstTotalOffset, unkIsDst, WHEN_NO_DST, noBias, reykBestMatch },
                { noDstTotalOffset, unkIsDst, WHEN_DST, noBias, reykBestMatch },

                // The parameters match one zone: total offset, isDst and time.
                { dstTotalOffset, isDst, WHEN_DST, noBias, lonOnlyMatch },
                { dstTotalOffset, isDst, WHEN_DST, noBias, lonOnlyMatch },

                { noDstTotalOffset, notDst, WHEN_NO_DST, noBias, reykBestMatch },
                { noDstTotalOffset, notDst, WHEN_DST, noBias, reykBestMatch },

                // Some lookup failure cases where the total offset, isDst and time do not match any
                // zone.
                { dstTotalOffset, isDst, WHEN_NO_DST, noBias, noMatch },
                { dstTotalOffset, unkIsDst, WHEN_NO_DST, noBias, noMatch },
                { noDstTotalOffset, isDst, WHEN_NO_DST, noBias, noMatch },
                { noDstTotalOffset, isDst, WHEN_DST, noBias, noMatch },

                // Some bias cases below.

                // Multiple zones match but Reykjavik is the bias.
                { noDstTotalOffset, notDst, WHEN_NO_DST, REYK_TZ, reykBestMatch },

                // Multiple zones match but London is the bias.
                { noDstTotalOffset, notDst, WHEN_NO_DST, LON_TZ, lonBestMatch },

                // Multiple zones match but UTC is the bias.
                { noDstTotalOffset, notDst, WHEN_NO_DST, UTC_TZ, utcBestMatch },

                // The bias should be ignored: it matches a zone, but the offset is wrong so
                // should not be considered a match.
                { LON_DST_TOTAL_OFFSET, isDst, WHEN_DST, REYK_TZ, lonOnlyMatch },
                { LON_DST_TOTAL_OFFSET, unkIsDst, WHEN_DST, REYK_TZ, lonOnlyMatch },
        };
        executeLookupByOffsetWithBiasTestCases(countryTimeZones, testCases);
    }

    private static void executeLookupByOffsetWithBiasTestCases(
            CountryTimeZones countryTimeZones, Object[][] testCases) {

        List<String> failures = new ArrayList<>();
        for (int i = 0; i < testCases.length; i++) {
            Object[] testCase = testCases[i];
            int totalOffsetMillis = (int) testCase[0];
            Boolean isDst = (Boolean) testCase[1];
            long whenMillis = (Long) testCase[2];
            TimeZone bias = (TimeZone) testCase[3];
            OffsetResult expectedMatch = (OffsetResult) testCase[4];

            OffsetResult actualMatch;
            if (isDst == null) {
                actualMatch = countryTimeZones.lookupByOffsetWithBias(
                        whenMillis, bias, totalOffsetMillis);
            } else {
                actualMatch = countryTimeZones.lookupByOffsetWithBias(
                        whenMillis, bias, totalOffsetMillis, isDst);
            }

            if (!offsetResultEquals(expectedMatch, actualMatch)) {
                Function<TimeZone, String> timeZoneFormatter =
                        x -> x == null ? "null" : x.getID();
                Function<OffsetResult, String> offsetResultFormatter =
                        x -> x == null ? "null"
                                : "{" + x.getTimeZone().getID() + ", " + x.isOnlyMatch() + "}";
                failures.add("Fail: case=" + i
                        + ", totalOffsetMillis=" + totalOffsetMillis
                        + ", isDst=" + isDst
                        + ", whenMillis=" + whenMillis
                        + ", bias=" + timeZoneFormatter.apply(bias)
                        + ", expectedMatch=" + offsetResultFormatter.apply(expectedMatch)
                        + ", actualMatch=" + offsetResultFormatter.apply(actualMatch)
                        + "\n");
            }
        }
        if (!failures.isEmpty()) {
            fail("Failed:\n" + failures);
        }
    }

    @Test
    public void getEffectiveTimeZonesAt_noZones() {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings(), "test");
        assertEquals(timeZoneMappings(),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(0 /* whenMillis */));
        assertEquals(timeZoneMappings(),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(Long.MIN_VALUE));
        assertEquals(timeZoneMappings(),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(Long.MAX_VALUE));
    }

    @Test
    public void getEffectiveTimeZonesAt_oneZone() {
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London"), "test");
        assertEquals(timeZoneMappings("Europe/London"),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(0));
        assertEquals(timeZoneMappings("Europe/London"),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(Long.MIN_VALUE));
        assertEquals(timeZoneMappings("Europe/London"),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(Long.MAX_VALUE));
    }

    @Test
    public void getEffectiveTimeZonesAt_filtering() {
        TimeZoneMapping alwaysUsed = timeZoneMapping("Europe/London", null /* notUsedAfter */);

        long mappingNotUsedAfterMillis = 0L;
        TimeZoneMapping notAlwaysUsed = timeZoneMapping("Europe/Paris",
                mappingNotUsedAfterMillis /* notUsedAfter */);

        List<TimeZoneMapping> timeZoneMappings = list(alwaysUsed, notAlwaysUsed);
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings, "test");

        // Before and at mappingNotUsedAfterMillis, both mappings are "effective".
        assertEquals(list(alwaysUsed, notAlwaysUsed),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(Long.MIN_VALUE));
        assertEquals(list(alwaysUsed, notAlwaysUsed),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(mappingNotUsedAfterMillis));

        // The following should filter the second mapping because it's not "effective" after
        // mappingNotUsedAfterMillis.
        assertEquals(list(alwaysUsed),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(mappingNotUsedAfterMillis + 1));
        assertEquals(list(alwaysUsed),
                countryTimeZones.getEffectiveTimeZoneMappingsAt(Long.MAX_VALUE));
    }

    @Test
    public void hasUtcZone_everUseUtcHintOverridesZoneInformation() {
        // The country has a single zone. Europe/London uses UTC in Winter.
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Etc/UTC", false /* defaultTimeZoneBoost */, false /* everUsesUtc */,
                timeZoneMappings("Etc/UTC"), "test");
        assertFalse(countryTimeZones.hasUtcZone(WHEN_DST));
        assertFalse(countryTimeZones.hasUtcZone(WHEN_NO_DST));
    }

    @Test
    public void hasUtcZone_singleZone() {
        // The country has a single zone. Europe/London uses UTC in Winter.
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/London", false /* defaultTimeZoneBoost */, true /* everUsesUtc */,
                timeZoneMappings("Europe/London"), "test");
        assertFalse(countryTimeZones.hasUtcZone(WHEN_DST));
        assertTrue(countryTimeZones.hasUtcZone(WHEN_NO_DST));
    }

    @Test
    public void hasUtcZone_multipleZonesWithUtc() {
        // The country has multiple zones. Europe/London uses UTC in Winter.
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "America/Los_Angeles", false /* defaultTimeZoneBoost */,
                true /* everUsesUtc */,
                timeZoneMappings("America/Los_Angeles", "America/New_York", "Europe/London"),
                "test");
        assertFalse(countryTimeZones.hasUtcZone(WHEN_DST));
        assertTrue(countryTimeZones.hasUtcZone(WHEN_NO_DST));
    }

    @Test
    public void hasUtcZone_multipleZonesWithoutUtc() {
        // The country has multiple zones, none of which use UTC.
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", "Europe/Paris", false /* defaultTimeZoneBoost */, false /* everUsesUtc */,
                timeZoneMappings("America/Los_Angeles", "America/New_York", "Europe/Paris"),
                "test");
        assertFalse(countryTimeZones.hasUtcZone(WHEN_DST));
        assertFalse(countryTimeZones.hasUtcZone(WHEN_NO_DST));
    }

    @Test
    public void hasUtcZone_emptyZones() {
        // The country has no valid zones.
        CountryTimeZones countryTimeZones = CountryTimeZones.createValidated(
                "xx", INVALID_TZ_ID, false /* defaultTimeZoneBoost */, false /* everUsesUtc */,
                timeZoneMappings(INVALID_TZ_ID), "test");
        assertTrue(countryTimeZones.getTimeZoneMappings().isEmpty());
        assertFalse(countryTimeZones.hasUtcZone(WHEN_DST));
        assertFalse(countryTimeZones.hasUtcZone(WHEN_NO_DST));
    }

    @Test
    public void timeZoneMapping_getTimeZone_badZoneId() {
        TimeZoneMapping timeZoneMapping =
                TimeZoneMapping.createForTests("DOES_NOT_EXIST", true, 1234L);
        try {
            timeZoneMapping.getTimeZone();
            fail();
        } catch (RuntimeException expected) {
        }
    }

    @Test
    public void timeZoneMapping_getTimeZone_validZoneId() {
        TimeZoneMapping timeZoneMapping =
                TimeZoneMapping.createForTests("Europe/London", true, 1234L);
        TimeZone timeZone = timeZoneMapping.getTimeZone();
        assertTrue(timeZone.isFrozen());
        assertEquals("Europe/London", timeZone.getID());
    }

    private void assertImmutableTimeZone(TimeZone timeZone) {
        try {
            timeZone.setRawOffset(1000);
            fail();
        } catch (UnsupportedOperationException expected) {
        }
    }

    private static <X> void assertImmutableList(List<X> list) {
        try {
            list.add(null);
            fail();
        } catch (UnsupportedOperationException expected) {
        }
    }

    private static void assertZoneEquals(TimeZone expected, TimeZone actual) {
        // TimeZone.equals() only checks the ID, but that's ok for these tests.
        assertEquals(expected, actual);
    }

    private static boolean offsetResultEquals(OffsetResult expected, OffsetResult actual) {
        return expected == actual
                || (expected != null && actual != null
                && Objects.equals(expected.getTimeZone().getID(), actual.getTimeZone().getID())
                && expected.isOnlyMatch() == actual.isOnlyMatch());
    }

    /**
     * Creates a list of default {@link TimeZoneMapping} objects with the specified time zone IDs.
     */
    private static TimeZoneMapping timeZoneMapping(String timeZoneId, Long notUsedAfterMillis) {
        return TimeZoneMapping.createForTests(
                        timeZoneId, true /* picker */, notUsedAfterMillis);
    }

    /**
     * Creates a list of default {@link TimeZoneMapping} objects with the specified time zone IDs.
     */
    private static List<TimeZoneMapping> timeZoneMappings(String... timeZoneIds) {
        return Arrays.stream(timeZoneIds)
                .map(x -> TimeZoneMapping.createForTests(
                        x, true /* picker */, null /* notUsedAfter */))
                .collect(Collectors.toList());
    }

    private static TimeZone zone(String id) {
        return TimeZone.getFrozenTimeZone(id);
    }

    private static <X> List<X> list(X... xes) {
        return Arrays.asList(xes);
    }
}