/*
 * Copyright 2019 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 com.android.server.timezonedetector;

import static android.app.timezonedetector.PhoneTimeZoneSuggestion.MATCH_TYPE_EMULATOR_ZONE_ID;
import static android.app.timezonedetector.PhoneTimeZoneSuggestion.MATCH_TYPE_NETWORK_COUNTRY_AND_OFFSET;
import static android.app.timezonedetector.PhoneTimeZoneSuggestion.MATCH_TYPE_NETWORK_COUNTRY_ONLY;
import static android.app.timezonedetector.PhoneTimeZoneSuggestion.MATCH_TYPE_TEST_NETWORK_OFFSET_ONLY;
import static android.app.timezonedetector.PhoneTimeZoneSuggestion.QUALITY_MULTIPLE_ZONES_WITH_DIFFERENT_OFFSETS;
import static android.app.timezonedetector.PhoneTimeZoneSuggestion.QUALITY_MULTIPLE_ZONES_WITH_SAME_OFFSET;
import static android.app.timezonedetector.PhoneTimeZoneSuggestion.QUALITY_SINGLE_ZONE;

import static com.android.server.timezonedetector.TimeZoneDetectorStrategy.PHONE_SCORE_HIGH;
import static com.android.server.timezonedetector.TimeZoneDetectorStrategy.PHONE_SCORE_HIGHEST;
import static com.android.server.timezonedetector.TimeZoneDetectorStrategy.PHONE_SCORE_LOW;
import static com.android.server.timezonedetector.TimeZoneDetectorStrategy.PHONE_SCORE_MEDIUM;
import static com.android.server.timezonedetector.TimeZoneDetectorStrategy.PHONE_SCORE_NONE;
import static com.android.server.timezonedetector.TimeZoneDetectorStrategy.PHONE_SCORE_USAGE_THRESHOLD;

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 android.app.timezonedetector.ManualTimeZoneSuggestion;
import android.app.timezonedetector.PhoneTimeZoneSuggestion;
import android.app.timezonedetector.PhoneTimeZoneSuggestion.MatchType;
import android.app.timezonedetector.PhoneTimeZoneSuggestion.Quality;

import com.android.server.timezonedetector.TimeZoneDetectorStrategy.QualifiedPhoneTimeZoneSuggestion;

import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Objects;

/**
 * White-box unit tests for {@link TimeZoneDetectorStrategy}.
 */
public class TimeZoneDetectorStrategyTest {

    /** A time zone used for initialization that does not occur elsewhere in tests. */
    private static final String ARBITRARY_TIME_ZONE_ID = "Etc/UTC";
    private static final int PHONE1_ID = 10000;
    private static final int PHONE2_ID = 20000;

    // Suggestion test cases are ordered so that each successive one is of the same or higher score
    // than the previous.
    private static final SuggestionTestCase[] TEST_CASES = new SuggestionTestCase[] {
            newTestCase(MATCH_TYPE_NETWORK_COUNTRY_ONLY,
                    QUALITY_MULTIPLE_ZONES_WITH_DIFFERENT_OFFSETS, PHONE_SCORE_LOW),
            newTestCase(MATCH_TYPE_NETWORK_COUNTRY_ONLY, QUALITY_MULTIPLE_ZONES_WITH_SAME_OFFSET,
                    PHONE_SCORE_MEDIUM),
            newTestCase(MATCH_TYPE_NETWORK_COUNTRY_AND_OFFSET,
                    QUALITY_MULTIPLE_ZONES_WITH_SAME_OFFSET, PHONE_SCORE_MEDIUM),
            newTestCase(MATCH_TYPE_NETWORK_COUNTRY_ONLY, QUALITY_SINGLE_ZONE, PHONE_SCORE_HIGH),
            newTestCase(MATCH_TYPE_NETWORK_COUNTRY_AND_OFFSET, QUALITY_SINGLE_ZONE,
                    PHONE_SCORE_HIGH),
            newTestCase(MATCH_TYPE_TEST_NETWORK_OFFSET_ONLY,
                    QUALITY_MULTIPLE_ZONES_WITH_SAME_OFFSET, PHONE_SCORE_HIGHEST),
            newTestCase(MATCH_TYPE_EMULATOR_ZONE_ID, QUALITY_SINGLE_ZONE, PHONE_SCORE_HIGHEST),
    };

    private TimeZoneDetectorStrategy mTimeZoneDetectorStrategy;
    private FakeTimeZoneDetectorStrategyCallback mFakeTimeZoneDetectorStrategyCallback;

    @Before
    public void setUp() {
        mFakeTimeZoneDetectorStrategyCallback = new FakeTimeZoneDetectorStrategyCallback();
        mTimeZoneDetectorStrategy =
                new TimeZoneDetectorStrategy(mFakeTimeZoneDetectorStrategyCallback);
    }

    @Test
    public void testEmptyPhoneSuggestions() {
        PhoneTimeZoneSuggestion phone1TimeZoneSuggestion = createEmptyPhone1Suggestion();
        PhoneTimeZoneSuggestion phone2TimeZoneSuggestion = createEmptyPhone2Suggestion();
        Script script = new Script()
                .initializeAutoTimeZoneDetection(true)
                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID);

        script.suggestPhoneTimeZone(phone1TimeZoneSuggestion)
                .verifyTimeZoneNotSet();

        // Assert internal service state.
        QualifiedPhoneTimeZoneSuggestion expectedPhone1ScoredSuggestion =
                new QualifiedPhoneTimeZoneSuggestion(phone1TimeZoneSuggestion, PHONE_SCORE_NONE);
        assertEquals(expectedPhone1ScoredSuggestion,
                mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
        assertNull(mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE2_ID));
        assertEquals(expectedPhone1ScoredSuggestion,
                mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

        script.suggestPhoneTimeZone(phone2TimeZoneSuggestion)
                .verifyTimeZoneNotSet();

        // Assert internal service state.
        QualifiedPhoneTimeZoneSuggestion expectedPhone2ScoredSuggestion =
                new QualifiedPhoneTimeZoneSuggestion(phone2TimeZoneSuggestion, PHONE_SCORE_NONE);
        assertEquals(expectedPhone1ScoredSuggestion,
                mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
        assertEquals(expectedPhone2ScoredSuggestion,
                mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE2_ID));
        // Phone 1 should always beat phone 2, all other things being equal.
        assertEquals(expectedPhone1ScoredSuggestion,
                mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());
    }

    @Test
    public void testFirstPlausiblePhoneSuggestionAcceptedWhenTimeZoneUninitialized() {
        SuggestionTestCase testCase = newTestCase(MATCH_TYPE_NETWORK_COUNTRY_ONLY,
                QUALITY_MULTIPLE_ZONES_WITH_DIFFERENT_OFFSETS, PHONE_SCORE_LOW);
        PhoneTimeZoneSuggestion lowQualitySuggestion =
                testCase.createSuggestion(PHONE1_ID, "America/New_York");

        // The device time zone setting is left uninitialized.
        Script script = new Script()
                .initializeAutoTimeZoneDetection(true);

        // The very first suggestion will be taken.
        script.suggestPhoneTimeZone(lowQualitySuggestion)
                .verifyTimeZoneSetAndReset(lowQualitySuggestion);

        // Assert internal service state.
        QualifiedPhoneTimeZoneSuggestion expectedScoredSuggestion =
                new QualifiedPhoneTimeZoneSuggestion(lowQualitySuggestion, testCase.expectedScore);
        assertEquals(expectedScoredSuggestion,
                mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
        assertEquals(expectedScoredSuggestion,
                mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

        // Another low quality suggestion will be ignored now that the setting is initialized.
        PhoneTimeZoneSuggestion lowQualitySuggestion2 =
                testCase.createSuggestion(PHONE1_ID, "America/Los_Angeles");
        script.suggestPhoneTimeZone(lowQualitySuggestion2)
                .verifyTimeZoneNotSet();

        // Assert internal service state.
        QualifiedPhoneTimeZoneSuggestion expectedScoredSuggestion2 =
                new QualifiedPhoneTimeZoneSuggestion(lowQualitySuggestion2, testCase.expectedScore);
        assertEquals(expectedScoredSuggestion2,
                mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
        assertEquals(expectedScoredSuggestion2,
                mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());
    }

    /**
     * Confirms that toggling the auto time zone detection setting has the expected behavior when
     * the strategy is "opinionated".
     */
    @Test
    public void testTogglingAutoTimeZoneDetection() {
        Script script = new Script();

        for (SuggestionTestCase testCase : TEST_CASES) {
            // Start with the device in a known state.
            script.initializeAutoTimeZoneDetection(false)
                    .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID);

            PhoneTimeZoneSuggestion suggestion =
                    testCase.createSuggestion(PHONE1_ID, "Europe/London");
            script.suggestPhoneTimeZone(suggestion);

            // When time zone detection is not enabled, the time zone suggestion will not be set
            // regardless of the score.
            script.verifyTimeZoneNotSet();

            // Assert internal service state.
            QualifiedPhoneTimeZoneSuggestion expectedScoredSuggestion =
                    new QualifiedPhoneTimeZoneSuggestion(suggestion, testCase.expectedScore);
            assertEquals(expectedScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedScoredSuggestion,
                    mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

            // Toggling the time zone setting on should cause the device setting to be set.
            script.autoTimeZoneDetectionEnabled(true);

            // When time zone detection is already enabled the suggestion (if it scores highly
            // enough) should be set immediately.
            if (testCase.expectedScore >= PHONE_SCORE_USAGE_THRESHOLD) {
                script.verifyTimeZoneSetAndReset(suggestion);
            } else {
                script.verifyTimeZoneNotSet();
            }

            // Assert internal service state.
            assertEquals(expectedScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedScoredSuggestion,
                    mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

            // Toggling the time zone setting should off should do nothing.
            script.autoTimeZoneDetectionEnabled(false)
                    .verifyTimeZoneNotSet();

            // Assert internal service state.
            assertEquals(expectedScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedScoredSuggestion,
                    mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());
        }
    }

    @Test
    public void testPhoneSuggestionsSinglePhone() {
        Script script = new Script()
                .initializeAutoTimeZoneDetection(true)
                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID);

        for (SuggestionTestCase testCase : TEST_CASES) {
            makePhone1SuggestionAndCheckState(script, testCase);
        }

        /*
         * This is the same test as above but the test cases are in
         * reverse order of their expected score. New suggestions always replace previous ones:
         * there's effectively no history and so ordering shouldn't make any difference.
         */

        // Each test case will have the same or lower score than the last.
        ArrayList<SuggestionTestCase> descendingCasesByScore =
                new ArrayList<>(Arrays.asList(TEST_CASES));
        Collections.reverse(descendingCasesByScore);

        for (SuggestionTestCase testCase : descendingCasesByScore) {
            makePhone1SuggestionAndCheckState(script, testCase);
        }
    }

    private void makePhone1SuggestionAndCheckState(Script script, SuggestionTestCase testCase) {
        // Give the next suggestion a different zone from the currently set device time zone;
        String currentZoneId = mFakeTimeZoneDetectorStrategyCallback.getDeviceTimeZone();
        String suggestionZoneId =
                "Europe/London".equals(currentZoneId) ? "Europe/Paris" : "Europe/London";
        PhoneTimeZoneSuggestion zonePhone1Suggestion =
                testCase.createSuggestion(PHONE1_ID, suggestionZoneId);
        QualifiedPhoneTimeZoneSuggestion expectedZonePhone1ScoredSuggestion =
                new QualifiedPhoneTimeZoneSuggestion(zonePhone1Suggestion, testCase.expectedScore);

        script.suggestPhoneTimeZone(zonePhone1Suggestion);
        if (testCase.expectedScore >= PHONE_SCORE_USAGE_THRESHOLD) {
            script.verifyTimeZoneSetAndReset(zonePhone1Suggestion);
        } else {
            script.verifyTimeZoneNotSet();
        }

        // Assert internal service state.
        assertEquals(expectedZonePhone1ScoredSuggestion,
                mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
        assertEquals(expectedZonePhone1ScoredSuggestion,
                mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());
    }

    /**
     * Tries a set of test cases to see if the phone with the lowest ID is given preference. This
     * test also confirms that the time zone setting would only be set if a suggestion is of
     * sufficient quality.
     */
    @Test
    public void testMultiplePhoneSuggestionScoringAndPhoneIdBias() {
        String[] zoneIds = { "Europe/London", "Europe/Paris" };
        PhoneTimeZoneSuggestion emptyPhone1Suggestion = createEmptyPhone1Suggestion();
        PhoneTimeZoneSuggestion emptyPhone2Suggestion = createEmptyPhone2Suggestion();
        QualifiedPhoneTimeZoneSuggestion expectedEmptyPhone1ScoredSuggestion =
                new QualifiedPhoneTimeZoneSuggestion(emptyPhone1Suggestion, PHONE_SCORE_NONE);
        QualifiedPhoneTimeZoneSuggestion expectedEmptyPhone2ScoredSuggestion =
                new QualifiedPhoneTimeZoneSuggestion(emptyPhone2Suggestion, PHONE_SCORE_NONE);

        Script script = new Script()
                .initializeAutoTimeZoneDetection(true)
                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID)
                // Initialize the latest suggestions as empty so we don't need to worry about nulls
                // below for the first loop.
                .suggestPhoneTimeZone(emptyPhone1Suggestion)
                .suggestPhoneTimeZone(emptyPhone2Suggestion)
                .resetState();

        for (SuggestionTestCase testCase : TEST_CASES) {
            PhoneTimeZoneSuggestion zonePhone1Suggestion =
                    testCase.createSuggestion(PHONE1_ID, zoneIds[0]);
            PhoneTimeZoneSuggestion zonePhone2Suggestion =
                    testCase.createSuggestion(PHONE2_ID, zoneIds[1]);
            QualifiedPhoneTimeZoneSuggestion expectedZonePhone1ScoredSuggestion =
                    new QualifiedPhoneTimeZoneSuggestion(zonePhone1Suggestion,
                            testCase.expectedScore);
            QualifiedPhoneTimeZoneSuggestion expectedZonePhone2ScoredSuggestion =
                    new QualifiedPhoneTimeZoneSuggestion(zonePhone2Suggestion,
                            testCase.expectedScore);

            // Start the test by making a suggestion for phone 1.
            script.suggestPhoneTimeZone(zonePhone1Suggestion);
            if (testCase.expectedScore >= PHONE_SCORE_USAGE_THRESHOLD) {
                script.verifyTimeZoneSetAndReset(zonePhone1Suggestion);
            } else {
                script.verifyTimeZoneNotSet();
            }

            // Assert internal service state.
            assertEquals(expectedZonePhone1ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedEmptyPhone2ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE2_ID));
            assertEquals(expectedZonePhone1ScoredSuggestion,
                    mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

            // Phone 2 then makes an alternative suggestion with an identical score. Phone 1's
            // suggestion should still "win" if it is above the required threshold.
            script.suggestPhoneTimeZone(zonePhone2Suggestion);
            script.verifyTimeZoneNotSet();

            // Assert internal service state.
            assertEquals(expectedZonePhone1ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedZonePhone2ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE2_ID));
            // Phone 1 should always beat phone 2, all other things being equal.
            assertEquals(expectedZonePhone1ScoredSuggestion,
                    mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

            // Withdrawing phone 1's suggestion should leave phone 2 as the new winner. Since the
            // zoneId is different, the time zone setting should be updated if the score is high
            // enough.
            script.suggestPhoneTimeZone(emptyPhone1Suggestion);
            if (testCase.expectedScore >= PHONE_SCORE_USAGE_THRESHOLD) {
                script.verifyTimeZoneSetAndReset(zonePhone2Suggestion);
            } else {
                script.verifyTimeZoneNotSet();
            }

            // Assert internal service state.
            assertEquals(expectedEmptyPhone1ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedZonePhone2ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE2_ID));
            assertEquals(expectedZonePhone2ScoredSuggestion,
                    mTimeZoneDetectorStrategy.findBestPhoneSuggestionForTests());

            // Reset the state for the next loop.
            script.suggestPhoneTimeZone(emptyPhone2Suggestion)
                    .verifyTimeZoneNotSet();
            assertEquals(expectedEmptyPhone1ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE1_ID));
            assertEquals(expectedEmptyPhone2ScoredSuggestion,
                    mTimeZoneDetectorStrategy.getLatestPhoneSuggestion(PHONE2_ID));
        }
    }

    /**
     * The {@link TimeZoneDetectorStrategy.Callback} is left to detect whether changing the time
     * zone is actually necessary. This test proves that the service doesn't assume it knows the
     * current setting.
     */
    @Test
    public void testTimeZoneDetectorStrategyDoesNotAssumeCurrentSetting() {
        Script script = new Script()
                .initializeAutoTimeZoneDetection(true);

        SuggestionTestCase testCase =
                newTestCase(MATCH_TYPE_NETWORK_COUNTRY_AND_OFFSET, QUALITY_SINGLE_ZONE,
                        PHONE_SCORE_HIGH);
        PhoneTimeZoneSuggestion losAngelesSuggestion =
                testCase.createSuggestion(PHONE1_ID, "America/Los_Angeles");
        PhoneTimeZoneSuggestion newYorkSuggestion =
                testCase.createSuggestion(PHONE1_ID, "America/New_York");

        // Initialization.
        script.suggestPhoneTimeZone(losAngelesSuggestion)
                .verifyTimeZoneSetAndReset(losAngelesSuggestion);
        // Suggest it again - it should not be set because it is already set.
        script.suggestPhoneTimeZone(losAngelesSuggestion)
                .verifyTimeZoneNotSet();

        // Toggling time zone detection should set the device time zone only if the current setting
        // value is different from the most recent phone suggestion.
        script.autoTimeZoneDetectionEnabled(false)
                .verifyTimeZoneNotSet()
                .autoTimeZoneDetectionEnabled(true)
                .verifyTimeZoneNotSet();

        // Simulate a user turning auto detection off, a new suggestion being made while auto
        // detection is off, and the user turning it on again.
        script.autoTimeZoneDetectionEnabled(false)
                .suggestPhoneTimeZone(newYorkSuggestion)
                .verifyTimeZoneNotSet();
        // Latest suggestion should be used.
        script.autoTimeZoneDetectionEnabled(true)
                .verifyTimeZoneSetAndReset(newYorkSuggestion);
    }

    @Test
    public void testManualSuggestion_autoTimeZoneDetectionEnabled() {
        Script script = new Script()
                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID)
                .initializeAutoTimeZoneDetection(true);

        // Auto time zone detection is enabled so the manual suggestion should be ignored.
        script.suggestManualTimeZone(createManualSuggestion("Europe/Paris"))
            .verifyTimeZoneNotSet();
    }


    @Test
    public void testManualSuggestion_autoTimeZoneDetectionDisabled() {
        Script script = new Script()
                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID)
                .initializeAutoTimeZoneDetection(false);

        // Auto time zone detection is disabled so the manual suggestion should be used.
        ManualTimeZoneSuggestion manualSuggestion = createManualSuggestion("Europe/Paris");
        script.suggestManualTimeZone(manualSuggestion)
            .verifyTimeZoneSetAndReset(manualSuggestion);
    }

    private ManualTimeZoneSuggestion createManualSuggestion(String zoneId) {
        return new ManualTimeZoneSuggestion(zoneId);
    }

    private static PhoneTimeZoneSuggestion createEmptyPhone1Suggestion() {
        return new PhoneTimeZoneSuggestion.Builder(PHONE1_ID).build();
    }

    private static PhoneTimeZoneSuggestion createEmptyPhone2Suggestion() {
        return new PhoneTimeZoneSuggestion.Builder(PHONE2_ID).build();
    }

    static class FakeTimeZoneDetectorStrategyCallback implements TimeZoneDetectorStrategy.Callback {

        private boolean mAutoTimeZoneDetectionEnabled;
        private TestState<TimeZoneChange> mTimeZoneChanges = new TestState<>();
        private String mTimeZoneId;

        @Override
        public boolean isAutoTimeZoneDetectionEnabled() {
            return mAutoTimeZoneDetectionEnabled;
        }

        @Override
        public boolean isDeviceTimeZoneInitialized() {
            return mTimeZoneId != null;
        }

        @Override
        public String getDeviceTimeZone() {
            return mTimeZoneId;
        }

        @Override
        public void setDeviceTimeZone(String zoneId, boolean withNetworkBroadcast) {
            mTimeZoneId = zoneId;
            mTimeZoneChanges.set(new TimeZoneChange(zoneId, withNetworkBroadcast));
        }

        void initializeAutoTimeZoneDetection(boolean enabled) {
            mAutoTimeZoneDetectionEnabled = enabled;
        }

        void initializeTimeZone(String zoneId) {
            mTimeZoneId = zoneId;
        }

        void setAutoTimeZoneDetectionEnabled(boolean enabled) {
            mAutoTimeZoneDetectionEnabled = enabled;
        }

        void assertTimeZoneNotSet() {
            mTimeZoneChanges.assertHasNotBeenSet();
        }

        void assertTimeZoneSet(String timeZoneId, boolean withNetworkBroadcast) {
            mTimeZoneChanges.assertHasBeenSet();
            mTimeZoneChanges.assertChangeCount(1);
            TimeZoneChange expectedChange = new TimeZoneChange(timeZoneId, withNetworkBroadcast);
            mTimeZoneChanges.assertLatestEquals(expectedChange);
        }

        void commitAllChanges() {
            mTimeZoneChanges.commitLatest();
        }
    }

    private static class TimeZoneChange {
        private final String mTimeZoneId;
        private final boolean mWithNetworkBroadcast;

        private TimeZoneChange(String timeZoneId, boolean withNetworkBroadcast) {
            mTimeZoneId = timeZoneId;
            mWithNetworkBroadcast = withNetworkBroadcast;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            TimeZoneChange that = (TimeZoneChange) o;
            return mWithNetworkBroadcast == that.mWithNetworkBroadcast
                    && mTimeZoneId.equals(that.mTimeZoneId);
        }

        @Override
        public int hashCode() {
            return Objects.hash(mTimeZoneId, mWithNetworkBroadcast);
        }
    }

    /** Some piece of state that tests want to track. */
    private static class TestState<T> {
        private T mInitialValue;
        private LinkedList<T> mValues = new LinkedList<>();

        void init(T value) {
            mValues.clear();
            mInitialValue = value;
        }

        void set(T value) {
            mValues.addFirst(value);
        }

        boolean hasBeenSet() {
            return mValues.size() > 0;
        }

        void assertHasNotBeenSet() {
            assertFalse(hasBeenSet());
        }

        void assertHasBeenSet() {
            assertTrue(hasBeenSet());
        }

        void commitLatest() {
            if (hasBeenSet()) {
                mInitialValue = mValues.getLast();
                mValues.clear();
            }
        }

        void assertLatestEquals(T expected) {
            assertEquals(expected, getLatest());
        }

        void assertChangeCount(int expectedCount) {
            assertEquals(expectedCount, mValues.size());
        }

        public T getLatest() {
            if (hasBeenSet()) {
                return mValues.getFirst();
            }
            return mInitialValue;
        }
    }

    /**
     * A "fluent" class allows reuse of code in tests: initialization, simulation and verification
     * logic.
     */
    private class Script {

        Script initializeAutoTimeZoneDetection(boolean enabled) {
            mFakeTimeZoneDetectorStrategyCallback.initializeAutoTimeZoneDetection(enabled);
            return this;
        }

        Script initializeTimeZoneSetting(String zoneId) {
            mFakeTimeZoneDetectorStrategyCallback.initializeTimeZone(zoneId);
            return this;
        }

        Script autoTimeZoneDetectionEnabled(boolean enabled) {
            mFakeTimeZoneDetectorStrategyCallback.setAutoTimeZoneDetectionEnabled(enabled);
            mTimeZoneDetectorStrategy.handleAutoTimeZoneDetectionChange();
            return this;
        }

        /** Simulates the time zone detection strategy receiving a phone-originated suggestion. */
        Script suggestPhoneTimeZone(PhoneTimeZoneSuggestion phoneTimeZoneSuggestion) {
            mTimeZoneDetectorStrategy.suggestPhoneTimeZone(phoneTimeZoneSuggestion);
            return this;
        }

        /** Simulates the time zone detection strategy receiving a user-originated suggestion. */
        Script suggestManualTimeZone(ManualTimeZoneSuggestion manualTimeZoneSuggestion) {
            mTimeZoneDetectorStrategy.suggestManualTimeZone(manualTimeZoneSuggestion);
            return this;
        }

        Script verifyTimeZoneNotSet() {
            mFakeTimeZoneDetectorStrategyCallback.assertTimeZoneNotSet();
            return this;
        }

        Script verifyTimeZoneSetAndReset(PhoneTimeZoneSuggestion suggestion) {
            // Phone suggestions should cause a TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE
            // broadcast.
            boolean withNetworkBroadcast = true;
            mFakeTimeZoneDetectorStrategyCallback.assertTimeZoneSet(
                    suggestion.getZoneId(), withNetworkBroadcast);
            mFakeTimeZoneDetectorStrategyCallback.commitAllChanges();
            return this;
        }

        Script verifyTimeZoneSetAndReset(ManualTimeZoneSuggestion suggestion) {
            // Manual suggestions should not cause a TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE
            // broadcast.
            boolean withNetworkBroadcast = false;
            mFakeTimeZoneDetectorStrategyCallback.assertTimeZoneSet(
                    suggestion.getZoneId(), withNetworkBroadcast);
            mFakeTimeZoneDetectorStrategyCallback.commitAllChanges();
            return this;
        }

        Script resetState() {
            mFakeTimeZoneDetectorStrategyCallback.commitAllChanges();
            return this;
        }
    }

    private static class SuggestionTestCase {
        public final int matchType;
        public final int quality;
        public final int expectedScore;

        SuggestionTestCase(int matchType, int quality, int expectedScore) {
            this.matchType = matchType;
            this.quality = quality;
            this.expectedScore = expectedScore;
        }

        private PhoneTimeZoneSuggestion createSuggestion(int phoneId, String zoneId) {
            return new PhoneTimeZoneSuggestion.Builder(phoneId)
                    .setZoneId(zoneId)
                    .setMatchType(matchType)
                    .setQuality(quality)
                    .build();
        }
    }

    private static SuggestionTestCase newTestCase(
            @MatchType int matchType, @Quality int quality, int expectedScore) {
        return new SuggestionTestCase(matchType, quality, expectedScore);
    }
}