Merge "Merge Screen Attention and Screen timeout Settings."

tests/robotests/src/com/android/settings/core/PreferenceXmlParserUtilsTest.java

@@ -16,6 +16,8 @@
 
 package com.android.settings.core;
 
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
+
 import static com.android.settings.core.PreferenceXmlParserUtils.METADATA_APPEND;
 import static com.android.settings.core.PreferenceXmlParserUtils.METADATA_KEY;
 import static com.android.settings.core.PreferenceXmlParserUtils.METADATA_KEYWORDS;
@@ -38,7 +40,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
@@ -52,7 +53,7 @@ import java.util.Objects;
  * uncommon (such as summaryOn).
  *
  * If changing a preference file breaks a test in this test file, please replace its reference
- * with another preference with a matchin replacement attribute.
+ * with another preference with a matching replacement attribute.
  */
 @RunWith(RobolectricTestRunner.class)
 public class PreferenceXmlParserUtilsTest {
@@ -61,43 +62,43 @@ public class PreferenceXmlParserUtilsTest {
 
     @Before
     public void setUp() {
-        mContext = RuntimeEnvironment.application;
+        mContext = getApplicationContext();
     }
 
     @Test
     public void testDataTitleValid_ReturnsPreferenceTitle() {
         XmlResourceParser parser = getChildByType(R.xml.display_settings,
-                "com.android.settings.display.TimeoutListPreference");
+                "com.android.settings.display.darkmode.DarkModePreference");
         final AttributeSet attrs = Xml.asAttributeSet(parser);
         String title = PreferenceXmlParserUtils.getDataTitle(mContext, attrs);
-        String expTitle = mContext.getString(R.string.screen_timeout);
+        String expTitle = mContext.getString(R.string.dark_ui_mode);
         assertThat(title).isEqualTo(expTitle);
     }
 
     @Test
     public void testDataKeywordsValid_ReturnsPreferenceKeywords() {
         XmlResourceParser parser = getChildByType(R.xml.display_settings,
-                "com.android.settings.display.TimeoutListPreference");
+                "com.android.settings.display.darkmode.DarkModePreference");
         final AttributeSet attrs = Xml.asAttributeSet(parser);
         String keywords = PreferenceXmlParserUtils.getDataKeywords(mContext, attrs);
-        String expKeywords = mContext.getString(R.string.keywords_screen_timeout);
+        String expKeywords = mContext.getString(R.string.keywords_dark_ui_mode);
         assertThat(keywords).isEqualTo(expKeywords);
     }
 
     @Test
     public void testDataKeyValid_ReturnsPreferenceKey() {
         XmlResourceParser parser = getChildByType(R.xml.display_settings,
-                "com.android.settings.display.TimeoutListPreference");
+                "com.android.settings.display.darkmode.DarkModePreference");
         final AttributeSet attrs = Xml.asAttributeSet(parser);
         String key = PreferenceXmlParserUtils.getDataKey(mContext, attrs);
-        String expKey = "screen_timeout";
+        String expKey = "dark_ui_mode";
         assertThat(key).isEqualTo(expKey);
     }
 
     @Test
     public void testDataSummaryValid_ReturnsPreferenceSummary() {
-        XmlResourceParser parser = getChildByType(R.xml.display_settings,
-                "com.android.settings.display.TimeoutListPreference");
+        XmlResourceParser parser = getChildByType(R.xml.sound_settings,
+                "com.android.settings.DefaultRingtonePreference");
         final AttributeSet attrs = Xml.asAttributeSet(parser);
         String summary = PreferenceXmlParserUtils.getDataSummary(mContext, attrs);
         String expSummary = mContext.getString(R.string.summary_placeholder);

tests/robotests/src/com/android/settings/display/AdaptiveSleepDetailPreferenceControllerTest.java

@@ -1,127 +0,0 @@
-/*
- * Copyright (C) 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.settings.display;
-
-import static com.android.settings.core.BasePreferenceController.AVAILABLE;
-import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.pm.PackageManager;
-import android.os.UserHandle;
-import android.os.UserManager;
-
-import com.android.internal.R;
-import com.android.settings.bluetooth.RestrictionUtils;
-import com.android.settings.testutils.shadow.SettingsShadowResources;
-import com.android.settingslib.RestrictedLockUtils;
-import com.android.settingslib.RestrictedSwitchPreference;
-
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
-
-@RunWith(RobolectricTestRunner.class)
-@Config(shadows = {SettingsShadowResources.class})
-public class AdaptiveSleepDetailPreferenceControllerTest {
-    private static RestrictedLockUtils.EnforcedAdmin sFakeEnforcedAdmin;
-
-    @BeforeClass
-    public static void beforeClass() {
-        sFakeEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin(
-                new ComponentName("test.package", "test.Class"),
-                UserHandle.of(10));
-    }
-
-    private AdaptiveSleepDetailPreferenceController mController;
-    @Mock
-    private PackageManager mPackageManager;
-    @Mock
-    private RestrictionUtils mRestrictionUtils;
-    @Mock
-    private RestrictedSwitchPreference mPreference;
-
-    private Context mContext;
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-        mContext = Mockito.spy(RuntimeEnvironment.application);
-        doReturn(mPackageManager).when(mContext).getPackageManager();
-        mController = new AdaptiveSleepDetailPreferenceController(mContext, "test_key",
-                mRestrictionUtils);
-    }
-
-    @Test
-    public void isSliceable_returnTrue() {
-        mController.onPreferenceChange(null, true);
-        assertThat(mController.isSliceable()).isTrue();
-    }
-
-    @Test
-    public void isPublicSlice_returnTrue() {
-        assertThat(mController.isPublicSlice()).isTrue();
-    }
-
-    @Test
-    public void getAvailabilityStatus_configTrueSet_shouldReturnAvailable() {
-        SettingsShadowResources.overrideResource(R.bool.config_adaptive_sleep_available, true);
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
-    }
-
-    @Test
-    public void getAvailabilityStatus_configFalseSet_shouldReturnUnsupportedOnDevice() {
-        SettingsShadowResources.overrideResource(R.bool.config_adaptive_sleep_available, false);
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
-    }
-
-    @Test
-    public void updateState_noRestriction_allowScreenAttentionSet() {
-        when(mRestrictionUtils.checkIfRestrictionEnforced(mContext,
-                UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT)).thenReturn(null);
-
-        mController.updateState(mPreference);
-
-        verify(mPreference, never()).setDisabledByAdmin(
-                any(RestrictedLockUtils.EnforcedAdmin.class));
-    }
-
-    @Test
-    public void updateState_enforceRestrictions_disallowScreenAttentionSet() {
-        when(mRestrictionUtils.checkIfRestrictionEnforced(mContext,
-                UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT)).thenReturn(sFakeEnforcedAdmin);
-
-        mController.updateState(mPreference);
-
-        verify(mPreference).setDisabledByAdmin(sFakeEnforcedAdmin);
-    }
-}

tests/robotests/src/com/android/settings/display/AdaptiveSleepPermissionPreferenceControllerTest.java

@@ -11,73 +11,69 @@
  * 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
+ * limitations under the License.
  */
 
 package com.android.settings.display;
 
-import static com.android.settings.core.BasePreferenceController.AVAILABLE_UNSEARCHABLE;
-
-import static com.google.common.truth.Truth.assertThat;
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
-import android.Manifest;
 import android.content.Context;
 import android.content.pm.PackageManager;
 
-import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
 
 @RunWith(RobolectricTestRunner.class)
 public class AdaptiveSleepPermissionPreferenceControllerTest {
-    private final static String PACKAGE_NAME = "package_name";
+    private Context mContext;
     private AdaptiveSleepPermissionPreferenceController mController;
+
     @Mock
     private PackageManager mPackageManager;
     @Mock
-    private Preference mPreference;
+    private PreferenceScreen mScreen;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        Context context = Mockito.spy(RuntimeEnvironment.application);
-        doReturn(mPackageManager).when(context).getPackageManager();
-        doReturn(PACKAGE_NAME).when(mPackageManager).getAttentionServicePackageName();
-        doReturn(PackageManager.PERMISSION_GRANTED).when(mPackageManager).checkPermission(
-                Manifest.permission.CAMERA, PACKAGE_NAME);
-        mController = new AdaptiveSleepPermissionPreferenceController(context, "test_key");
-        doReturn(mController.getPreferenceKey()).when(mPreference).getKey();
+        mContext = spy(getApplicationContext());
+
+        doReturn(mPackageManager).when(mContext).getPackageManager();
+        when(mPackageManager.getAttentionServicePackageName()).thenReturn("some.package");
+        when(mPackageManager.checkPermission(any(), any())).thenReturn(
+                PackageManager.PERMISSION_GRANTED);
+
+        mController = new AdaptiveSleepPermissionPreferenceController(mContext);
     }
 
     @Test
-    public void getAvailabilityStatus_returnAvailableUnsearchable() {
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE_UNSEARCHABLE);
+    public void addToScreen_normalCase_hidePreference() {
+        mController.addToScreen(mScreen);
+
+        verify(mScreen, never()).addPreference(mController.mPreference);
     }
 
     @Test
-    public void updateStates_permissionGranted_preferenceInvisible() {
-        mController.updateState(mPreference);
+    public void addToScreen_permissionNotGranted_showPreference() {
+        when(mPackageManager.checkPermission(any(), any())).thenReturn(
+                PackageManager.PERMISSION_DENIED);
 
-        verify(mPreference).setVisible(false);
-    }
+        mController.addToScreen(mScreen);
 
-    @Test
-    public void updateStates_permissionRevoked_preferenceVisible() {
-        doReturn(PackageManager.PERMISSION_DENIED).when(mPackageManager).checkPermission(
-                Manifest.permission.CAMERA, PACKAGE_NAME);
-
-        mController.updateState(mPreference);
-
-        verify(mPreference).setVisible(true);
+        verify(mScreen).addPreference(mController.mPreference);
     }
 }

tests/robotests/src/com/android/settings/display/AdaptiveSleepPreferenceControllerTest.java

@@ -18,27 +18,32 @@ package com.android.settings.display;
 
 import static android.provider.Settings.Secure.ADAPTIVE_SLEEP;
 
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
+
 import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
 
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.os.UserManager;
 import android.provider.Settings;
 
-import androidx.preference.Preference;
 import androidx.preference.PreferenceScreen;
 
-import com.android.settings.R;
+import com.android.settings.bluetooth.RestrictionUtils;
+import com.android.settingslib.RestrictedLockUtils;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -46,13 +51,9 @@ import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
 
 @RunWith(RobolectricTestRunner.class)
 public class AdaptiveSleepPreferenceControllerTest {
-
-    private static final String PREFERENCE_KEY = "adaptive_sleep";
-
     private Context mContext;
     private AdaptiveSleepPreferenceController mController;
     private ContentResolver mContentResolver;
@@ -62,114 +63,101 @@ public class AdaptiveSleepPreferenceControllerTest {
     @Mock
     private PreferenceScreen mScreen;
     @Mock
-    private Preference mPreference;
+    private RestrictionUtils mRestrictionUtils;
+    @Mock
+    private RestrictedLockUtils.EnforcedAdmin mEnforcedAdmin;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-
-        mContext = spy(RuntimeEnvironment.application);
+        mContext = spy(getApplicationContext());
         mContentResolver = mContext.getContentResolver();
 
         doReturn(mPackageManager).when(mContext).getPackageManager();
         when(mPackageManager.getAttentionServicePackageName()).thenReturn("some.package");
         when(mPackageManager.checkPermission(any(), any())).thenReturn(
                 PackageManager.PERMISSION_GRANTED);
+        when(mRestrictionUtils.checkIfRestrictionEnforced(any(),
+                eq(UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT))).thenReturn(null);
 
-        mController = new AdaptiveSleepPreferenceController(mContext, PREFERENCE_KEY);
-        when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
+        mController = new AdaptiveSleepPreferenceController(mContext, mRestrictionUtils);
     }
 
     @Test
-    public void isControllerAvailable_ServiceUnavailable_returnUnsupported() {
-        doReturn(null).when(mPackageManager).resolveService(isA(Intent.class), anyInt());
+    public void controlSetting_preferenceChecked_FeatureTurnOn() {
+        mController.mPreference.setChecked(false);
+
+        mController.mPreference.performClick();
+
+        int mode = Settings.Secure.getInt(mContentResolver, ADAPTIVE_SLEEP, 0);
+        assertThat(mode).isEqualTo(1);
+    }
+
+    @Test
+    public void controlSetting_preferenceNotChecked_FeatureTurnOff() {
+        mController.mPreference.setChecked(true);
+
+        mController.mPreference.performClick();
+
+        int mode = Settings.Secure.getInt(mContentResolver, ADAPTIVE_SLEEP, 1);
+        assertThat(mode).isEqualTo(0);
+    }
+
+    @Test
+    public void isControllerAvailable_serviceNotSupported_returnUnsupportedCode() {
+        when(mPackageManager.resolveService(isA(Intent.class), anyInt())).thenReturn(null);
 
         assertThat(AdaptiveSleepPreferenceController.isControllerAvailable(mContext)).isEqualTo(
                 UNSUPPORTED_ON_DEVICE);
     }
 
     @Test
-    public void onPreferenceChange_turnOn_returnOn() {
-        mController.onPreferenceChange(null, true);
-
-        final int mode = Settings.Secure.getInt(mContentResolver, ADAPTIVE_SLEEP, 0);
-        assertThat(mode).isEqualTo(1);
+    public void hasSufficientPermission_permissionGranted_returnTrue() {
+        assertThat(AdaptiveSleepPreferenceController.hasSufficientPermission(
+                mPackageManager)).isTrue();
     }
 
     @Test
-    public void onPreferenceChange_turnOff_returnOff() {
-        mController.onPreferenceChange(null, false);
-
-        final int mode = Settings.Secure.getInt(mContentResolver, ADAPTIVE_SLEEP, 1);
-        assertThat(mode).isEqualTo(0);
-    }
-
-    @Test
-    public void setChecked_updatesCorrectly() {
-        mController.setChecked(true);
-
-        assertThat(mController.isChecked()).isTrue();
-
-        mController.setChecked(false);
-
-        assertThat(mController.isChecked()).isFalse();
-    }
-
-    @Test
-    public void isChecked_no() {
-        Settings.System.putInt(mContentResolver, ADAPTIVE_SLEEP, 0);
-
-        assertThat(mController.isChecked()).isFalse();
-    }
-
-    @Test
-    public void isChecked_yes() {
-        Settings.Secure.putInt(mContentResolver, ADAPTIVE_SLEEP, 1);
-
-        assertThat(mController.isChecked()).isTrue();
-    }
-
-    @Test
-    public void getSummary_settingOn_shouldReturnOnSummary() {
-        mController.setChecked(true);
-
-        assertThat(mController.getSummary())
-                .isEqualTo(mContext.getText(R.string.adaptive_sleep_summary_on));
-    }
-
-    @Test
-    public void getSummary_settingOff_shouldReturnOffSummary() {
-        mController.setChecked(false);
-
-        assertThat(mController.getSummary())
-                .isEqualTo(mContext.getText(R.string.adaptive_sleep_summary_off));
-    }
-
-    @Test
-    public void isSliceable_returnsTrue() {
-        final AdaptiveSleepPreferenceController controller =
-                new AdaptiveSleepPreferenceController(mContext, "any_key");
-        assertThat(controller.isSliceable()).isTrue();
-    }
-
-    @Test
-    public void isChecked_returnsFalseWhenNotSufficientPermissions() {
-        when(mPackageManager.checkPermission(any(), any())).thenReturn(
-                PackageManager.PERMISSION_DENIED);
-        final AdaptiveSleepPreferenceController controller = new AdaptiveSleepPreferenceController(
-                mContext, PREFERENCE_KEY);
-
-        controller.setChecked(true);
-        assertThat(controller.isChecked()).isFalse();
-    }
-
-    @Test
-    public void isEnabled_returnsFalseWhenNotSufficientPermissions() {
+    public void hasSufficientPermission_permissionNotGranted_returnFalse() {
         when(mPackageManager.checkPermission(any(), any())).thenReturn(
                 PackageManager.PERMISSION_DENIED);
 
-        mController.setChecked(true);
-        mController.displayPreference(mScreen);
-        assertThat(mPreference.isEnabled()).isFalse();
+        assertThat(AdaptiveSleepPreferenceController.hasSufficientPermission(
+                mPackageManager)).isFalse();
+    }
+
+    @Test
+    public void addToScreen_normalCase_enablePreference() {
+        mController.mPreference.setEnabled(false);
+        when(mPackageManager.checkPermission(any(), any())).thenReturn(
+                PackageManager.PERMISSION_GRANTED);
+
+        mController.addToScreen(mScreen);
+
+        assertThat(mController.mPreference.isEnabled()).isTrue();
+        verify(mScreen).addPreference(mController.mPreference);
+    }
+
+    @Test
+    public void addToScreen_permissionNotGranted_disablePreference() {
+        mController.mPreference.setEnabled(true);
+        when(mPackageManager.checkPermission(any(), any())).thenReturn(
+                PackageManager.PERMISSION_DENIED);
+
+        mController.addToScreen(mScreen);
+
+        assertThat(mController.mPreference.isEnabled()).isFalse();
+    }
+
+    @Test
+    public void addToScreen_enforcedAdmin_disablePreference() {
+        mController.mPreference.setEnabled(true);
+
+        when(mRestrictionUtils.checkIfRestrictionEnforced(any(),
+                eq(UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT))).thenReturn(mEnforcedAdmin);
+
+        mController.addToScreen(mScreen);
+
+        assertThat(mController.mPreference.isEnabled()).isFalse();
     }
 }

tests/robotests/src/com/android/settings/display/ScreenTimeoutSettingsTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2020 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.settings.display;
+
+import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;
+
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.res.Resources;
+import android.provider.SearchIndexableResource;
+import android.provider.Settings;
+
+import com.android.settings.R;
+
+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;
+
+import java.util.List;
+
+@RunWith(RobolectricTestRunner.class)
+public class ScreenTimeoutSettingsTest {
+    private static final String[] TIMEOUT_ENTRIES = new String[]{"15 secs", "30 secs"};
+    private static final String[] TIMEOUT_VALUES = new String[]{"15000", "30000"};
+
+    private ScreenTimeoutSettings mSettings;
+    private Context mContext;
+    private ContentResolver mContentResolver;
+
+    @Mock
+    private Resources mResources;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(getApplicationContext());
+        mSettings = spy(new ScreenTimeoutSettings());
+        mContentResolver = mContext.getContentResolver();
+
+        doReturn(TIMEOUT_ENTRIES).when(mResources).getStringArray(R.array.screen_timeout_entries);
+        doReturn(TIMEOUT_VALUES).when(mResources).getStringArray(R.array.screen_timeout_entries);
+        doReturn(mResources).when(mSettings).getResources();
+        doReturn(mContext).when(mSettings).getContext();
+    }
+
+    @Test
+    public void searchIndexProvider_shouldIndexResource() {
+        final List<SearchIndexableResource> indexRes =
+                ScreenTimeoutSettings.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex(
+                        mContext, true /* enabled */);
+
+        assertThat(indexRes).isNotNull();
+        assertThat(indexRes.get(0).xmlResId).isEqualTo(mSettings.getPreferenceScreenResId());
+    }
+
+    @Test
+    public void getDefaultKey_returnCurrentTimeout() {
+        long timeout = Long.parseLong(TIMEOUT_VALUES[1]);
+        Settings.System.putLong(mContentResolver, SCREEN_OFF_TIMEOUT, timeout);
+
+        String key = mSettings.getDefaultKey();
+
+        assertThat(key).isEqualTo(TIMEOUT_VALUES[1]);
+    }
+
+    @Test
+    public void setDefaultKey_controlCurrentScreenTimeout() {
+        mSettings.setDefaultKey(TIMEOUT_VALUES[0]);
+
+        long timeout = Settings.System.getLong(mContentResolver, SCREEN_OFF_TIMEOUT,
+                30000 /* default */);
+
+        assertThat(Long.toString(timeout)).isEqualTo(TIMEOUT_VALUES[0]);
+    }
+}