Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Time / Zone service refactoring

Browse Source 
No functional changes intended, only cleanups and refactoring to
services and tests.

Bug: 236612872
Test: compile / treehugger
Change-Id: I74d8f4dfad0c80263afee1f6dac89cc27d3d89ee
This commit is contained in:
Neil Fuller
2022-10-05 16:06:26 +01:00
parent e932ab9a5e
commit 4841be3dac
4 changed files with 145 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
services/core/java/com/android/server/timedetector/TimeDetectorService.java
View File

@@ -88,8 +88,10 @@ public final class TimeDetectorService extends ITimeDetectorService.Stub
new TimeDetectorInternalImpl(context, handler, timeDetectorStrategy);
publishLocalService(TimeDetectorInternal.class, internal);
CallerIdentityInjector callerIdentityInjector = CallerIdentityInjector.REAL;
TimeDetectorService service = new TimeDetectorService(
context, handler, serviceConfigAccessor, timeDetectorStrategy);
context, handler, callerIdentityInjector, serviceConfigAccessor,
timeDetectorStrategy, NtpTrustedTime.getInstance(context));
// Publish the binder service so it can be accessed from other (appropriately
// permissioned) processes.
@@ -114,23 +116,15 @@ public final class TimeDetectorService extends ITimeDetectorService.Stub
@VisibleForTesting
public TimeDetectorService(@NonNull Context context, @NonNull Handler handler,
@NonNull ServiceConfigAccessor serviceConfigAccessor,
@NonNull TimeDetectorStrategy timeDetectorStrategy) {
this(context, handler, serviceConfigAccessor, timeDetectorStrategy,
CallerIdentityInjector.REAL, NtpTrustedTime.getInstance(context));
}
@VisibleForTesting
public TimeDetectorService(@NonNull Context context, @NonNull Handler handler,
@NonNull CallerIdentityInjector callerIdentityInjector,
@NonNull ServiceConfigAccessor serviceConfigAccessor,
@NonNull TimeDetectorStrategy timeDetectorStrategy,
@NonNull CallerIdentityInjector callerIdentityInjector,
@NonNull NtpTrustedTime ntpTrustedTime) {
mContext = Objects.requireNonNull(context);
mHandler = Objects.requireNonNull(handler);
mCallerIdentityInjector = Objects.requireNonNull(callerIdentityInjector);
mServiceConfigAccessor = Objects.requireNonNull(serviceConfigAccessor);
mTimeDetectorStrategy = Objects.requireNonNull(timeDetectorStrategy);
mCallerIdentityInjector = Objects.requireNonNull(callerIdentityInjector);
mNtpTrustedTime = Objects.requireNonNull(ntpTrustedTime);
// Wire up a change listener so that ITimeZoneDetectorListeners can be notified when

16
services/core/java/com/android/server/timezonedetector/TimeZoneDetectorService.java
View File

@@ -102,8 +102,10 @@ public final class TimeZoneDetectorService extends ITimeZoneDetectorService.Stub
// Publish the binder service so it can be accessed from other (appropriately
// permissioned) processes.
TimeZoneDetectorService service = TimeZoneDetectorService.create(
context, handler, serviceConfigAccessor, timeZoneDetectorStrategy);
CallerIdentityInjector callerIdentityInjector = CallerIdentityInjector.REAL;
TimeZoneDetectorService service = new TimeZoneDetectorService(
context, handler, callerIdentityInjector, serviceConfigAccessor,
timeZoneDetectorStrategy);
// Dump the device activity monitor when the service is dumped.
service.addDumpable(deviceActivityMonitor);
@@ -142,16 +144,6 @@ public final class TimeZoneDetectorService extends ITimeZoneDetectorService.Stub
@GuardedBy("mDumpables")
private final List<Dumpable> mDumpables = new ArrayList<>();
private static TimeZoneDetectorService create(
@NonNull Context context, @NonNull Handler handler,
@NonNull ServiceConfigAccessor serviceConfigAccessor,
@NonNull TimeZoneDetectorStrategy timeZoneDetectorStrategy) {
CallerIdentityInjector callerIdentityInjector = CallerIdentityInjector.REAL;
return new TimeZoneDetectorService(context, handler, callerIdentityInjector,
serviceConfigAccessor, timeZoneDetectorStrategy);
}
@VisibleForTesting
public TimeZoneDetectorService(@NonNull Context context, @NonNull Handler handler,
@NonNull CallerIdentityInjector callerIdentityInjector,

198
services/tests/servicestests/src/com/android/server/timedetector/TimeDetectorServiceTest.java
View File

@@ -22,7 +22,6 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
@@ -104,8 +103,8 @@ public class TimeDetectorServiceTest {
mMockNtpTrustedTime = mock(NtpTrustedTime.class);
mTimeDetectorService = new TimeDetectorService(
mMockContext, mTestHandler, mFakeServiceConfigAccessor,
mFakeTimeDetectorStrategy, mTestCallerIdentityInjector, mMockNtpTrustedTime);
mMockContext, mTestHandler, mTestCallerIdentityInjector, mFakeServiceConfigAccessor,
mFakeTimeDetectorStrategy, mMockNtpTrustedTime);
}
@After
@@ -114,19 +113,14 @@ public class TimeDetectorServiceTest {
mHandlerThread.join();
}
@Test(expected = SecurityException.class)
@Test
public void testGetCapabilitiesAndConfig_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
try {
mTimeDetectorService.getCapabilitiesAndConfig();
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class, mTimeDetectorService::getCapabilitiesAndConfig);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -141,40 +135,30 @@ public class TimeDetectorServiceTest {
mTimeDetectorService.getCapabilitiesAndConfig());
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testAddListener_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ITimeDetectorListener mockListener = mock(ITimeDetectorListener.class);
try {
mTimeDetectorService.addListener(mockListener);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class, () -> mTimeDetectorService.addListener(mockListener));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testRemoveListener_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ITimeDetectorListener mockListener = mock(ITimeDetectorListener.class);
try {
mTimeDetectorService.removeListener(mockListener);
fail("Expected a SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.removeListener(mockListener));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -193,8 +177,7 @@ public class TimeDetectorServiceTest {
mTimeDetectorService.addListener(mockListener);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener).asBinder();
verify(mockListenerBinder).linkToDeath(any(), anyInt());
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
@@ -213,8 +196,7 @@ public class TimeDetectorServiceTest {
mTestHandler.waitForMessagesToBeProcessed();
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener).onChange();
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
reset(mockListenerBinder, mockListener, mMockContext);
@@ -230,8 +212,7 @@ public class TimeDetectorServiceTest {
mTimeDetectorService.removeListener(mockListener);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener).asBinder();
verify(mockListenerBinder).unlinkToDeath(any(), eq(0));
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
@@ -246,28 +227,23 @@ public class TimeDetectorServiceTest {
mTimeDetectorService.updateConfiguration(autoDetectDisabledConfiguration);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener, never()).onChange();
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
reset(mockListenerBinder, mockListener, mMockContext);
}
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestTelephonyTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
TelephonyTimeSuggestion timeSuggestion = createTelephonyTimeSuggestion();
try {
mTimeDetectorService.suggestTelephonyTime(timeSuggestion);
fail();
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.suggestTelephonyTime(timeSuggestion));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE), anyString());
}
@Test
@@ -279,27 +255,22 @@ public class TimeDetectorServiceTest {
mTestHandler.assertTotalMessagesEnqueued(1);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE),
anyString());
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE), anyString());
mTestHandler.waitForMessagesToBeProcessed();
mFakeTimeDetectorStrategy.verifySuggestTelephonyTimeCalled(timeSuggestion);
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestManualTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingOrSelfPermission(anyString(), any());
ManualTimeSuggestion manualTimeSuggestion = createManualTimeSuggestion();
try {
mTimeDetectorService.suggestManualTime(manualTimeSuggestion);
fail();
} finally {
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.suggestManualTime(manualTimeSuggestion));
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE), anyString());
}
@Test
@@ -313,24 +284,20 @@ public class TimeDetectorServiceTest {
mTestCallerIdentityInjector.getCallingUserId(), manualTimeSuggestion);
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE),
anyString());
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestNetworkTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingOrSelfPermission(anyString(), any());
NetworkTimeSuggestion networkTimeSuggestion = createNetworkTimeSuggestion();
try {
mTimeDetectorService.suggestNetworkTime(networkTimeSuggestion);
fail();
} finally {
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME), anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.suggestNetworkTime(networkTimeSuggestion));
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME), anyString());
}
@Test
@@ -348,19 +315,16 @@ public class TimeDetectorServiceTest {
mFakeTimeDetectorStrategy.verifySuggestNetworkTimeCalled(networkTimeSuggestion);
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestGnssTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingOrSelfPermission(anyString(), any());
GnssTimeSuggestion gnssTimeSuggestion = createGnssTimeSuggestion();
try {
mTimeDetectorService.suggestGnssTime(gnssTimeSuggestion);
fail();
} finally {
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME), anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.suggestGnssTime(gnssTimeSuggestion));
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME), anyString());
}
@Test
@@ -378,19 +342,16 @@ public class TimeDetectorServiceTest {
mFakeTimeDetectorStrategy.verifySuggestGnssTimeCalled(gnssTimeSuggestion);
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestExternalTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ExternalTimeSuggestion externalTimeSuggestion = createExternalTimeSuggestion();
try {
mTimeDetectorService.suggestExternalTime(externalTimeSuggestion);
fail();
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_EXTERNAL_TIME), anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.suggestExternalTime(externalTimeSuggestion));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_EXTERNAL_TIME), anyString());
}
@Test
@@ -434,23 +395,18 @@ public class TimeDetectorServiceTest {
TimeState actualState = mTimeDetectorService.getTimeState();
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
assertEquals(actualState, fakeState);
}
@Test(expected = SecurityException.class)
@Test
public void testGetTimeState_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
try {
mTimeDetectorService.getTimeState();
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class, mTimeDetectorService::getTimeState);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -461,24 +417,19 @@ public class TimeDetectorServiceTest {
mTimeDetectorService.setTimeState(state);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
assertEquals(mFakeTimeDetectorStrategy.getTimeState(), state);
}
@Test(expected = SecurityException.class)
@Test
public void testSetTimeState_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
TimeState state = new TimeState(new UnixEpochTime(12345L, 98765L), true);
try {
mTimeDetectorService.setTimeState(state);
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class, () -> mTimeDetectorService.setTimeState(state));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -490,23 +441,19 @@ public class TimeDetectorServiceTest {
assertFalse(mTimeDetectorService.confirmTime(confirmationTime));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
mFakeTimeDetectorStrategy.verifyConfirmTimeCalled(confirmationTime);
}
@Test(expected = SecurityException.class)
@Test
public void testConfirmTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
try {
mTimeDetectorService.confirmTime(new UnixEpochTime(12345L, 98765L));
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.confirmTime(new UnixEpochTime(12345L, 98765L)));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -524,24 +471,19 @@ public class TimeDetectorServiceTest {
mTestCallerIdentityInjector.getCallingUserId(), timeSuggestion);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testSetManualTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ManualTimeSuggestion timeSuggestion = createManualTimeSuggestion();
try {
mTimeDetectorService.setManualTime(timeSuggestion);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeDetectorService.setManualTime(timeSuggestion));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -562,7 +504,7 @@ public class TimeDetectorServiceTest {
.build();
}
private static ConfigurationInternal createConfigurationInternal(boolean autoDetectionEnabled) {
static ConfigurationInternal createConfigurationInternal(boolean autoDetectionEnabled) {
return new ConfigurationInternal.Builder(ARBITRARY_USER_ID)
.setUserConfigAllowed(true)
.setAutoDetectionSupported(true)

187
services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorServiceTest.java
View File

@@ -18,7 +18,7 @@ package com.android.server.timezonedetector;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.fail;
import static org.junit.Assert.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
@@ -97,19 +97,14 @@ public class TimeZoneDetectorServiceTest {
mHandlerThread.join();
}
@Test(expected = SecurityException.class)
@Test
public void testGetCapabilitiesAndConfig_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
try {
mTimeZoneDetectorService.getCapabilitiesAndConfig();
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class, mTimeZoneDetectorService::getCapabilitiesAndConfig);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -124,40 +119,31 @@ public class TimeZoneDetectorServiceTest {
mTimeZoneDetectorService.getCapabilitiesAndConfig());
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testAddListener_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ITimeZoneDetectorListener mockListener = mock(ITimeZoneDetectorListener.class);
try {
mTimeZoneDetectorService.addListener(mockListener);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.addListener(mockListener));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testRemoveListener_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ITimeZoneDetectorListener mockListener = mock(ITimeZoneDetectorListener.class);
try {
mTimeZoneDetectorService.removeListener(mockListener);
fail("Expected a SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.removeListener(mockListener));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -176,8 +162,7 @@ public class TimeZoneDetectorServiceTest {
mTimeZoneDetectorService.addListener(mockListener);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener).asBinder();
verify(mockListenerBinder).linkToDeath(any(), anyInt());
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
@@ -196,8 +181,7 @@ public class TimeZoneDetectorServiceTest {
mTestHandler.waitForMessagesToBeProcessed();
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener).onChange();
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
reset(mockListenerBinder, mockListener, mMockContext);
@@ -213,8 +197,7 @@ public class TimeZoneDetectorServiceTest {
mTimeZoneDetectorService.removeListener(mockListener);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener).asBinder();
verify(mockListenerBinder).unlinkToDeath(any(), eq(0));
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
@@ -229,28 +212,23 @@ public class TimeZoneDetectorServiceTest {
mTimeZoneDetectorService.updateConfiguration(autoDetectDisabledConfiguration);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
verify(mockListener, never()).onChange();
verifyNoMoreInteractions(mockListenerBinder, mockListener, mMockContext);
reset(mockListenerBinder, mockListener, mMockContext);
}
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestGeolocationTimeZone_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingOrSelfPermission(anyString(), any());
GeolocationTimeZoneSuggestion timeZoneSuggestion = createGeolocationTimeZoneSuggestion();
try {
mTimeZoneDetectorService.suggestGeolocationTimeZone(timeZoneSuggestion);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME_ZONE),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.suggestGeolocationTimeZone(timeZoneSuggestion));
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME_ZONE), anyString());
}
@Test
@@ -263,27 +241,22 @@ public class TimeZoneDetectorServiceTest {
mTestHandler.assertTotalMessagesEnqueued(1);
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SET_TIME_ZONE),
anyString());
eq(android.Manifest.permission.SET_TIME_ZONE), anyString());
mTestHandler.waitForMessagesToBeProcessed();
mFakeTimeZoneDetectorStrategy.verifySuggestGeolocationTimeZoneCalled(timeZoneSuggestion);
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestManualTimeZone_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingOrSelfPermission(anyString(), any());
ManualTimeZoneSuggestion timeZoneSuggestion = createManualTimeZoneSuggestion();
try {
mTimeZoneDetectorService.suggestManualTimeZone(timeZoneSuggestion);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.suggestManualTimeZone(timeZoneSuggestion));
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE), anyString());
}
@Test
@@ -300,40 +273,31 @@ public class TimeZoneDetectorServiceTest {
mTestCallerIdentityInjector.getCallingUserId(), timeZoneSuggestion);
verify(mMockContext).enforceCallingOrSelfPermission(
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE),
anyString());
eq(android.Manifest.permission.SUGGEST_MANUAL_TIME_AND_ZONE), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestTelephonyTime_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
TelephonyTimeZoneSuggestion timeZoneSuggestion = createTelephonyTimeZoneSuggestion();
try {
mTimeZoneDetectorService.suggestTelephonyTimeZone(timeZoneSuggestion);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.suggestTelephonyTimeZone(timeZoneSuggestion));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testSuggestTelephonyTimeZone_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
TelephonyTimeZoneSuggestion timeZoneSuggestion = createTelephonyTimeZoneSuggestion();
try {
mTimeZoneDetectorService.suggestTelephonyTimeZone(timeZoneSuggestion);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.suggestTelephonyTimeZone(timeZoneSuggestion));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE), anyString());
}
@Test
@@ -345,8 +309,7 @@ public class TimeZoneDetectorServiceTest {
mTestHandler.assertTotalMessagesEnqueued(1);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE),
anyString());
eq(android.Manifest.permission.SUGGEST_TELEPHONY_TIME_AND_ZONE), anyString());
mTestHandler.waitForMessagesToBeProcessed();
mFakeTimeZoneDetectorStrategy.verifySuggestTelephonyTimeZoneCalled(timeZoneSuggestion);
@@ -361,23 +324,18 @@ public class TimeZoneDetectorServiceTest {
TimeZoneState actualState = mTimeZoneDetectorService.getTimeZoneState();
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
assertEquals(actualState, fakeState);
}
@Test(expected = SecurityException.class)
@Test
public void testGetTimeZoneState_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
try {
mTimeZoneDetectorService.getTimeZoneState();
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class, mTimeZoneDetectorService::getTimeZoneState);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -388,24 +346,20 @@ public class TimeZoneDetectorServiceTest {
mTimeZoneDetectorService.setTimeZoneState(state);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
assertEquals(mFakeTimeZoneDetectorStrategy.getTimeZoneState(), state);
}
@Test(expected = SecurityException.class)
@Test
public void testSetTimeZoneState_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
TimeZoneState state = new TimeZoneState("Europe/Narnia", true);
try {
mTimeZoneDetectorService.setTimeZoneState(state);
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.setTimeZoneState(state));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -416,23 +370,19 @@ public class TimeZoneDetectorServiceTest {
assertFalse(mTimeZoneDetectorService.confirmTimeZone("Europe/Narnia"));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
mFakeTimeZoneDetectorStrategy.verifyConfirmTimeZoneCalled("Europe/Narnia");
}
@Test(expected = SecurityException.class)
@Test
public void testConfirmTimeZone_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
try {
mTimeZoneDetectorService.confirmTimeZone("Europe/Narnia");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.confirmTimeZone("Europe/Narnia"));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test
@@ -450,24 +400,19 @@ public class TimeZoneDetectorServiceTest {
mTestCallerIdentityInjector.getCallingUserId(), timeZoneSuggestion);
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test(expected = SecurityException.class)
@Test
public void testSetManualTimeZone_withoutPermission() {
doThrow(new SecurityException("Mock"))
.when(mMockContext).enforceCallingPermission(anyString(), any());
ManualTimeZoneSuggestion timeZoneSuggestion = createManualTimeZoneSuggestion();
try {
mTimeZoneDetectorService.setManualTimeZone(timeZoneSuggestion);
fail("Expected SecurityException");
} finally {
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION),
anyString());
}
assertThrows(SecurityException.class,
() -> mTimeZoneDetectorService.setManualTimeZone(timeZoneSuggestion));
verify(mMockContext).enforceCallingPermission(
eq(android.Manifest.permission.MANAGE_TIME_AND_ZONE_DETECTION), anyString());
}
@Test