android-34/com/android/server/location/gnss/TimeDetectorNetworkTimeHelperTest.java - platform/prebuilts/fullsdk/sources - Git at Google

 /*
  * Copyright (C) 2022 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.location.gnss;

 import static com.android.server.location.gnss.TimeDetectorNetworkTimeHelper.MAX_NETWORK_TIME_AGE_MILLIS;
 import static com.android.server.location.gnss.TimeDetectorNetworkTimeHelper.NTP_REFRESH_INTERVAL_MILLIS;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;

 import android.app.time.UnixEpochTime;
 import android.platform.test.annotations.Presubmit;

 import com.android.server.location.gnss.NetworkTimeHelper.InjectTimeCallback;
 import com.android.server.location.gnss.TimeDetectorNetworkTimeHelper.Environment;
 import com.android.server.timedetector.NetworkTimeSuggestion;
 import com.android.server.timezonedetector.StateChangeListener;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;

 /**
  * Unit tests for {@link TimeDetectorNetworkTimeHelper}.
  */
 @RunWith(RobolectricTestRunner.class)
 @Presubmit
 public class TimeDetectorNetworkTimeHelperTest {

     private static final NetworkTimeSuggestion ARBITRARY_NETWORK_TIME =
             new NetworkTimeSuggestion(new UnixEpochTime(1234L, 7777L), 123);

     private FakeEnvironment mFakeEnvironment;
     @Mock private InjectTimeCallback mMockInjectTimeCallback;
     private TimeDetectorNetworkTimeHelper mTimeDetectorNetworkTimeHelper;

     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);

         mFakeEnvironment = new FakeEnvironment();
         mTimeDetectorNetworkTimeHelper = new TimeDetectorNetworkTimeHelper(
                 mFakeEnvironment, mMockInjectTimeCallback);

         // TimeDetectorNetworkTimeHelper should register for network time updates during
         // construction.
         mFakeEnvironment.assertHasNetworkTimeChangeListener();
     }

     @Test
     public void setPeriodicTimeInjectionMode_true() {
         testSetPeriodicTimeInjectionMode(true);
     }

     @Test
     public void setPeriodicTimeInjectionMode_false() {
         testSetPeriodicTimeInjectionMode(false);
     }

     private void testSetPeriodicTimeInjectionMode(boolean periodicTimeInjectionMode) {
         NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
         int millisElapsedSinceNetworkTimeReceived = 1000;
         mFakeEnvironment.pokeLatestNetworkTime(networkTime);

         long currentElapsedRealtimeMillis =
                 networkTime.getUnixEpochTime().getElapsedRealtimeMillis()
                         + millisElapsedSinceNetworkTimeReceived;
         mFakeEnvironment.pokeElapsedRealtimeMillis(currentElapsedRealtimeMillis);

         mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(periodicTimeInjectionMode);

         // All injections are async, so we have to simulate the async work taking place.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasImmediateCallback();
         mFakeEnvironment.simulateTimeAdvancing(1);

         // Any call to setPeriodicTimeInjectionMode() should result in an (async) injected time
         verify(mMockInjectTimeCallback).injectTime(
                 networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
                 networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
                 networkTime.getUncertaintyMillis());

         // Check whether the scheduled async is set up / not set up for the periodic request.
         if (periodicTimeInjectionMode) {
             mFakeEnvironment.assertHasScheduledAsyncCallback(
                     mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);
         } else {
             mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         }
     }

     @Test
     public void periodicInjectionBehavior() {
         // Set the elapsed realtime clock to an arbitrary start value.
         mFakeEnvironment.pokeElapsedRealtimeMillis(12345L);

         // Configure periodic time injections. Doing so should cause a time query, but no time is
         // available.
         mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(true);

         // All query/injections are async, so we have to simulate the async work taking place.
         mFakeEnvironment.assertHasImmediateCallback();
         mFakeEnvironment.simulateTimeAdvancing(1);

         // No time available, so no injection.
         verifyNoMoreInteractions(mMockInjectTimeCallback);

         // A periodic check should be scheduled.
         mFakeEnvironment.assertHasScheduledAsyncCallback(
                 mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);

         // Time passes...
         mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS / 2);

         // A network time becomes available: This should cause the registered listener to trigger.
         NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
         mFakeEnvironment.simulateLatestNetworkTimeChange(networkTime);

         // All query/injections are async, so we have to simulate the async work taking place,
         // causing a query, time injection and a re-schedule.
         mFakeEnvironment.simulateTimeAdvancing(1);
         verify(mMockInjectTimeCallback).injectTime(
                 networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
                 networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
                 networkTime.getUncertaintyMillis());

         // A new periodic check should be scheduled.
         mFakeEnvironment.assertHasNoImmediateCallback();

         mFakeEnvironment.assertHasScheduledAsyncCallback(
                 mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);

         int arbitraryIterationCount = 3;
         for (int i = 0; i < arbitraryIterationCount; i++) {
             // Advance by the amount needed for the scheduled work to run. That work should query
             // and inject.
             mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS);

             // All query/injections are async, so we have to simulate the async work taking place,
             // causing a query, time injection and a re-schedule.
             verify(mMockInjectTimeCallback).injectTime(
                     networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
                     networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
                     networkTime.getUncertaintyMillis());

             // A new periodic check should be scheduled.
             mFakeEnvironment.assertHasScheduledAsyncCallback(
                     mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);
             mFakeEnvironment.assertHasNoImmediateCallback();
         }
     }

     @Test
     public void networkTimeAvailableBehavior() {
         // Set the elapsed realtime clock to an arbitrary start value.
         mFakeEnvironment.pokeElapsedRealtimeMillis(12345L);

         // No periodic time injections. This call causes a time query, but no time is available yet.
         mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(false);

         // All query/injections are async, so we have to simulate the async work taking place.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasImmediateCallback();
         mFakeEnvironment.simulateTimeAdvancing(1);

         // No time available, so no injection.
         verifyNoMoreInteractions(mMockInjectTimeCallback);

         // No periodic check should be scheduled.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();

         // Time passes...
         mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS / 2);

         // A network time becomes available: This should cause the registered listener to trigger
         // and cause time to be injected.
         NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
         mFakeEnvironment.simulateLatestNetworkTimeChange(networkTime);

         // All query/injections are async, so we have to simulate the async work taking place,
         // causing a query, time injection and a re-schedule.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasImmediateCallback();
         mFakeEnvironment.simulateTimeAdvancing(1);
         verify(mMockInjectTimeCallback).injectTime(
                 networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
                 networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
                 networkTime.getUncertaintyMillis());

         // No periodic check should be scheduled.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasNoImmediateCallback();
     }

     @Test
     public void networkConnectivityAvailableBehavior() {
         // Set the elapsed realtime clock to an arbitrary start value.
         mFakeEnvironment.pokeElapsedRealtimeMillis(12345L);

         // No periodic time injections. This call causes a time query, but no time is available yet.
         mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(false);

         // All query/injections are async, so we have to simulate the async work taking place.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasImmediateCallback();
         mFakeEnvironment.simulateTimeAdvancing(1);

         // No time available, so no injection.
         verifyNoMoreInteractions(mMockInjectTimeCallback);

         // No periodic check should be scheduled.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();

         // Time passes...
         mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS / 2);

         NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
         mFakeEnvironment.pokeLatestNetworkTime(networkTime);

         // Simulate location code noticing that connectivity has changed and notifying the helper.
         mTimeDetectorNetworkTimeHelper.onNetworkAvailable();

         // All query/injections are async, so we have to simulate the async work taking place,
         // causing a query, time injection and a re-schedule.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasImmediateCallback();
         mFakeEnvironment.simulateTimeAdvancing(1);
         verify(mMockInjectTimeCallback).injectTime(
                 networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
                 networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
                 networkTime.getUncertaintyMillis());

         // No periodic check should be scheduled.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasNoImmediateCallback();
     }

     @Test
     public void oldTimesNotInjected() {
         NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
         mFakeEnvironment.pokeLatestNetworkTime(networkTime);

         int millisElapsedSinceNetworkTimeReceived = MAX_NETWORK_TIME_AGE_MILLIS;
         long currentElapsedRealtimeMillis =
                 networkTime.getUnixEpochTime().getElapsedRealtimeMillis()
                         + millisElapsedSinceNetworkTimeReceived;
         mFakeEnvironment.pokeElapsedRealtimeMillis(currentElapsedRealtimeMillis);

         mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(true);

         // All injections are async, so we have to simulate the async work taking place.
         mFakeEnvironment.assertHasNoScheduledAsyncCallback();
         mFakeEnvironment.assertHasImmediateCallback();

         // The age of the network time will now be MAX_NETWORK_TIME_AGE_MILLIS + 1, which is too
         // old to inject.
         mFakeEnvironment.simulateTimeAdvancing(1);

         // Old network times should not be injected.
         verify(mMockInjectTimeCallback, never()).injectTime(anyLong(), anyLong(), anyInt());

         // Check whether the scheduled async is set up / not set up for the periodic request.
         mFakeEnvironment.assertHasScheduledAsyncCallback(
                 mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);
     }

     /** A fake implementation of {@link Environment} for use by this test. */
     private static class FakeEnvironment implements Environment {

         private StateChangeListener mNetworkTimeUpdateListener;

         private long mCurrentElapsedRealtimeMillis;
         private NetworkTimeSuggestion mLatestNetworkTime;

         private TimeDetectorNetworkTimeHelper mImmediateAsyncCallback;
         private String mImmediateAsyncCallbackReason;

         private TimeDetectorNetworkTimeHelper mScheduledAsyncCallback;
         private long mScheduledAsyncRunnableTimeMillis;

         @Override
         public long elapsedRealtimeMillis() {
             return mCurrentElapsedRealtimeMillis;
         }

         @Override
         public NetworkTimeSuggestion getLatestNetworkTime() {
             return mLatestNetworkTime;
         }

         @Override
         public void setNetworkTimeUpdateListener(StateChangeListener stateChangeListener) {
             mNetworkTimeUpdateListener = stateChangeListener;
         }

         @Override
         public void requestImmediateTimeQueryCallback(TimeDetectorNetworkTimeHelper helper,
                 String reason) {
             if (mImmediateAsyncCallback != null) {
                 fail("Only one immediate callback expected at a time, found reason: "
                         + mImmediateAsyncCallbackReason);
             }
             mImmediateAsyncCallback = helper;
             mImmediateAsyncCallbackReason = reason;
         }

         @Override
         public void requestDelayedTimeQueryCallback(
                 TimeDetectorNetworkTimeHelper instance, long delayMillis) {
             mScheduledAsyncCallback = instance;
             mScheduledAsyncRunnableTimeMillis = mCurrentElapsedRealtimeMillis + delayMillis;
         }

         @Override
         public void clearDelayedTimeQueryCallback() {
             mScheduledAsyncCallback = null;
             mScheduledAsyncRunnableTimeMillis = -1;
         }

         void pokeLatestNetworkTime(NetworkTimeSuggestion networkTime) {
             mLatestNetworkTime = networkTime;
         }

         void pokeElapsedRealtimeMillis(long currentElapsedRealtimeMillis) {
             mCurrentElapsedRealtimeMillis = currentElapsedRealtimeMillis;
         }

         void simulateLatestNetworkTimeChange(NetworkTimeSuggestion networkTime) {
             mLatestNetworkTime = networkTime;
             mNetworkTimeUpdateListener.onChange();
         }

         void simulateTimeAdvancing(long durationMillis) {
             mCurrentElapsedRealtimeMillis += durationMillis;

             if (mImmediateAsyncCallback != null) {
                 TimeDetectorNetworkTimeHelper helper = mImmediateAsyncCallback;
                 String reason = mImmediateAsyncCallbackReason;
                 mImmediateAsyncCallback = null;
                 mImmediateAsyncCallbackReason = null;
                 helper.queryAndInjectNetworkTime(reason);
             }

             if (mScheduledAsyncCallback != null
                     && mCurrentElapsedRealtimeMillis >= mScheduledAsyncRunnableTimeMillis) {
                 TimeDetectorNetworkTimeHelper helper = mScheduledAsyncCallback;
                 mScheduledAsyncCallback = null;
                 mScheduledAsyncRunnableTimeMillis = -1;
                 helper.delayedQueryAndInjectNetworkTime();
             }
         }

         void assertHasNetworkTimeChangeListener() {
             assertNotNull(mNetworkTimeUpdateListener);
         }

         void assertHasImmediateCallback() {
             assertNotNull(mImmediateAsyncCallback);
         }

         void assertHasNoImmediateCallback() {
             assertNull(mImmediateAsyncCallback);
         }

         void assertHasScheduledAsyncCallback(long expectedScheduledAsyncRunnableTimeMillis) {
             assertNotNull(mScheduledAsyncCallback);
             assertEquals(expectedScheduledAsyncRunnableTimeMillis,
                     mScheduledAsyncRunnableTimeMillis);
         }

         void assertHasNoScheduledAsyncCallback() {
             assertNull(mScheduledAsyncCallback);
         }
     }
 }
	/*
	* Copyright (C) 2022 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.location.gnss;

	import static com.android.server.location.gnss.TimeDetectorNetworkTimeHelper.MAX_NETWORK_TIME_AGE_MILLIS;
	import static com.android.server.location.gnss.TimeDetectorNetworkTimeHelper.NTP_REFRESH_INTERVAL_MILLIS;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.fail;
	import static org.mockito.ArgumentMatchers.anyInt;
	import static org.mockito.ArgumentMatchers.anyLong;
	import static org.mockito.Mockito.never;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.verifyNoMoreInteractions;

	import android.app.time.UnixEpochTime;
	import android.platform.test.annotations.Presubmit;

	import com.android.server.location.gnss.NetworkTimeHelper.InjectTimeCallback;
	import com.android.server.location.gnss.TimeDetectorNetworkTimeHelper.Environment;
	import com.android.server.timedetector.NetworkTimeSuggestion;
	import com.android.server.timezonedetector.StateChangeListener;

	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;
	import org.robolectric.RobolectricTestRunner;

	/**
	* Unit tests for {@link TimeDetectorNetworkTimeHelper}.
	*/
	@RunWith(RobolectricTestRunner.class)
	@Presubmit
	public class TimeDetectorNetworkTimeHelperTest {

	private static final NetworkTimeSuggestion ARBITRARY_NETWORK_TIME =
	new NetworkTimeSuggestion(new UnixEpochTime(1234L, 7777L), 123);

	private FakeEnvironment mFakeEnvironment;
	@Mock private InjectTimeCallback mMockInjectTimeCallback;
	private TimeDetectorNetworkTimeHelper mTimeDetectorNetworkTimeHelper;

	@Before
	public void setUp() {
	MockitoAnnotations.initMocks(this);

	mFakeEnvironment = new FakeEnvironment();
	mTimeDetectorNetworkTimeHelper = new TimeDetectorNetworkTimeHelper(
	mFakeEnvironment, mMockInjectTimeCallback);

	// TimeDetectorNetworkTimeHelper should register for network time updates during
	// construction.
	mFakeEnvironment.assertHasNetworkTimeChangeListener();
	}

	@Test
	public void setPeriodicTimeInjectionMode_true() {
	testSetPeriodicTimeInjectionMode(true);
	}

	@Test
	public void setPeriodicTimeInjectionMode_false() {
	testSetPeriodicTimeInjectionMode(false);
	}

	private void testSetPeriodicTimeInjectionMode(boolean periodicTimeInjectionMode) {
	NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
	int millisElapsedSinceNetworkTimeReceived = 1000;
	mFakeEnvironment.pokeLatestNetworkTime(networkTime);

	long currentElapsedRealtimeMillis =
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis()
	+ millisElapsedSinceNetworkTimeReceived;
	mFakeEnvironment.pokeElapsedRealtimeMillis(currentElapsedRealtimeMillis);

	mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(periodicTimeInjectionMode);

	// All injections are async, so we have to simulate the async work taking place.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasImmediateCallback();
	mFakeEnvironment.simulateTimeAdvancing(1);

	// Any call to setPeriodicTimeInjectionMode() should result in an (async) injected time
	verify(mMockInjectTimeCallback).injectTime(
	networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
	networkTime.getUncertaintyMillis());

	// Check whether the scheduled async is set up / not set up for the periodic request.
	if (periodicTimeInjectionMode) {
	mFakeEnvironment.assertHasScheduledAsyncCallback(
	mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);
	} else {
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	}
	}

	@Test
	public void periodicInjectionBehavior() {
	// Set the elapsed realtime clock to an arbitrary start value.
	mFakeEnvironment.pokeElapsedRealtimeMillis(12345L);

	// Configure periodic time injections. Doing so should cause a time query, but no time is
	// available.
	mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(true);

	// All query/injections are async, so we have to simulate the async work taking place.
	mFakeEnvironment.assertHasImmediateCallback();
	mFakeEnvironment.simulateTimeAdvancing(1);

	// No time available, so no injection.
	verifyNoMoreInteractions(mMockInjectTimeCallback);

	// A periodic check should be scheduled.
	mFakeEnvironment.assertHasScheduledAsyncCallback(
	mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);

	// Time passes...
	mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS / 2);

	// A network time becomes available: This should cause the registered listener to trigger.
	NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
	mFakeEnvironment.simulateLatestNetworkTimeChange(networkTime);

	// All query/injections are async, so we have to simulate the async work taking place,
	// causing a query, time injection and a re-schedule.
	mFakeEnvironment.simulateTimeAdvancing(1);
	verify(mMockInjectTimeCallback).injectTime(
	networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
	networkTime.getUncertaintyMillis());

	// A new periodic check should be scheduled.
	mFakeEnvironment.assertHasNoImmediateCallback();

	mFakeEnvironment.assertHasScheduledAsyncCallback(
	mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);

	int arbitraryIterationCount = 3;
	for (int i = 0; i < arbitraryIterationCount; i++) {
	// Advance by the amount needed for the scheduled work to run. That work should query
	// and inject.
	mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS);

	// All query/injections are async, so we have to simulate the async work taking place,
	// causing a query, time injection and a re-schedule.
	verify(mMockInjectTimeCallback).injectTime(
	networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
	networkTime.getUncertaintyMillis());

	// A new periodic check should be scheduled.
	mFakeEnvironment.assertHasScheduledAsyncCallback(
	mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);
	mFakeEnvironment.assertHasNoImmediateCallback();
	}
	}

	@Test
	public void networkTimeAvailableBehavior() {
	// Set the elapsed realtime clock to an arbitrary start value.
	mFakeEnvironment.pokeElapsedRealtimeMillis(12345L);

	// No periodic time injections. This call causes a time query, but no time is available yet.
	mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(false);

	// All query/injections are async, so we have to simulate the async work taking place.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasImmediateCallback();
	mFakeEnvironment.simulateTimeAdvancing(1);

	// No time available, so no injection.
	verifyNoMoreInteractions(mMockInjectTimeCallback);

	// No periodic check should be scheduled.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();

	// Time passes...
	mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS / 2);

	// A network time becomes available: This should cause the registered listener to trigger
	// and cause time to be injected.
	NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
	mFakeEnvironment.simulateLatestNetworkTimeChange(networkTime);

	// All query/injections are async, so we have to simulate the async work taking place,
	// causing a query, time injection and a re-schedule.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasImmediateCallback();
	mFakeEnvironment.simulateTimeAdvancing(1);
	verify(mMockInjectTimeCallback).injectTime(
	networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
	networkTime.getUncertaintyMillis());

	// No periodic check should be scheduled.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasNoImmediateCallback();
	}

	@Test
	public void networkConnectivityAvailableBehavior() {
	// Set the elapsed realtime clock to an arbitrary start value.
	mFakeEnvironment.pokeElapsedRealtimeMillis(12345L);

	// No periodic time injections. This call causes a time query, but no time is available yet.
	mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(false);

	// All query/injections are async, so we have to simulate the async work taking place.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasImmediateCallback();
	mFakeEnvironment.simulateTimeAdvancing(1);

	// No time available, so no injection.
	verifyNoMoreInteractions(mMockInjectTimeCallback);

	// No periodic check should be scheduled.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();

	// Time passes...
	mFakeEnvironment.simulateTimeAdvancing(NTP_REFRESH_INTERVAL_MILLIS / 2);

	NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
	mFakeEnvironment.pokeLatestNetworkTime(networkTime);

	// Simulate location code noticing that connectivity has changed and notifying the helper.
	mTimeDetectorNetworkTimeHelper.onNetworkAvailable();

	// All query/injections are async, so we have to simulate the async work taking place,
	// causing a query, time injection and a re-schedule.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasImmediateCallback();
	mFakeEnvironment.simulateTimeAdvancing(1);
	verify(mMockInjectTimeCallback).injectTime(
	networkTime.getUnixEpochTime().getUnixEpochTimeMillis(),
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis(),
	networkTime.getUncertaintyMillis());

	// No periodic check should be scheduled.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasNoImmediateCallback();
	}

	@Test
	public void oldTimesNotInjected() {
	NetworkTimeSuggestion networkTime = ARBITRARY_NETWORK_TIME;
	mFakeEnvironment.pokeLatestNetworkTime(networkTime);

	int millisElapsedSinceNetworkTimeReceived = MAX_NETWORK_TIME_AGE_MILLIS;
	long currentElapsedRealtimeMillis =
	networkTime.getUnixEpochTime().getElapsedRealtimeMillis()
	+ millisElapsedSinceNetworkTimeReceived;
	mFakeEnvironment.pokeElapsedRealtimeMillis(currentElapsedRealtimeMillis);

	mTimeDetectorNetworkTimeHelper.setPeriodicTimeInjectionMode(true);

	// All injections are async, so we have to simulate the async work taking place.
	mFakeEnvironment.assertHasNoScheduledAsyncCallback();
	mFakeEnvironment.assertHasImmediateCallback();

	// The age of the network time will now be MAX_NETWORK_TIME_AGE_MILLIS + 1, which is too
	// old to inject.
	mFakeEnvironment.simulateTimeAdvancing(1);

	// Old network times should not be injected.
	verify(mMockInjectTimeCallback, never()).injectTime(anyLong(), anyLong(), anyInt());

	// Check whether the scheduled async is set up / not set up for the periodic request.
	mFakeEnvironment.assertHasScheduledAsyncCallback(
	mFakeEnvironment.elapsedRealtimeMillis() + NTP_REFRESH_INTERVAL_MILLIS);
	}

	/** A fake implementation of {@link Environment} for use by this test. */
	private static class FakeEnvironment implements Environment {

	private StateChangeListener mNetworkTimeUpdateListener;

	private long mCurrentElapsedRealtimeMillis;
	private NetworkTimeSuggestion mLatestNetworkTime;

	private TimeDetectorNetworkTimeHelper mImmediateAsyncCallback;
	private String mImmediateAsyncCallbackReason;

	private TimeDetectorNetworkTimeHelper mScheduledAsyncCallback;
	private long mScheduledAsyncRunnableTimeMillis;

	@Override
	public long elapsedRealtimeMillis() {
	return mCurrentElapsedRealtimeMillis;
	}

	@Override
	public NetworkTimeSuggestion getLatestNetworkTime() {
	return mLatestNetworkTime;
	}

	@Override
	public void setNetworkTimeUpdateListener(StateChangeListener stateChangeListener) {
	mNetworkTimeUpdateListener = stateChangeListener;
	}

	@Override
	public void requestImmediateTimeQueryCallback(TimeDetectorNetworkTimeHelper helper,
	String reason) {
	if (mImmediateAsyncCallback != null) {
	fail("Only one immediate callback expected at a time, found reason: "
	+ mImmediateAsyncCallbackReason);
	}
	mImmediateAsyncCallback = helper;
	mImmediateAsyncCallbackReason = reason;
	}

	@Override
	public void requestDelayedTimeQueryCallback(
	TimeDetectorNetworkTimeHelper instance, long delayMillis) {
	mScheduledAsyncCallback = instance;
	mScheduledAsyncRunnableTimeMillis = mCurrentElapsedRealtimeMillis + delayMillis;
	}

	@Override
	public void clearDelayedTimeQueryCallback() {
	mScheduledAsyncCallback = null;
	mScheduledAsyncRunnableTimeMillis = -1;
	}

	void pokeLatestNetworkTime(NetworkTimeSuggestion networkTime) {
	mLatestNetworkTime = networkTime;
	}

	void pokeElapsedRealtimeMillis(long currentElapsedRealtimeMillis) {
	mCurrentElapsedRealtimeMillis = currentElapsedRealtimeMillis;
	}

	void simulateLatestNetworkTimeChange(NetworkTimeSuggestion networkTime) {
	mLatestNetworkTime = networkTime;
	mNetworkTimeUpdateListener.onChange();
	}

	void simulateTimeAdvancing(long durationMillis) {
	mCurrentElapsedRealtimeMillis += durationMillis;

	if (mImmediateAsyncCallback != null) {
	TimeDetectorNetworkTimeHelper helper = mImmediateAsyncCallback;
	String reason = mImmediateAsyncCallbackReason;
	mImmediateAsyncCallback = null;
	mImmediateAsyncCallbackReason = null;
	helper.queryAndInjectNetworkTime(reason);
	}

	if (mScheduledAsyncCallback != null
	&& mCurrentElapsedRealtimeMillis >= mScheduledAsyncRunnableTimeMillis) {
	TimeDetectorNetworkTimeHelper helper = mScheduledAsyncCallback;
	mScheduledAsyncCallback = null;
	mScheduledAsyncRunnableTimeMillis = -1;
	helper.delayedQueryAndInjectNetworkTime();
	}
	}

	void assertHasNetworkTimeChangeListener() {
	assertNotNull(mNetworkTimeUpdateListener);
	}

	void assertHasImmediateCallback() {
	assertNotNull(mImmediateAsyncCallback);
	}

	void assertHasNoImmediateCallback() {
	assertNull(mImmediateAsyncCallback);
	}

	void assertHasScheduledAsyncCallback(long expectedScheduledAsyncRunnableTimeMillis) {
	assertNotNull(mScheduledAsyncCallback);
	assertEquals(expectedScheduledAsyncRunnableTimeMillis,
	mScheduledAsyncRunnableTimeMillis);
	}

	void assertHasNoScheduledAsyncCallback() {
	assertNull(mScheduledAsyncCallback);
	}
	}
	}