tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.accessibility;
  18
  19 import static com.google.common.truth.Truth.assertThat;
  20
  21 import static org.mockito.Mockito.doReturn;
  22 import static org.mockito.Mockito.spy;
  23
  24 import android.app.UiModeManager;
  25 import android.content.ContentResolver;
  26 import android.content.Context;
  27 import android.os.Vibrator;
  28 import android.provider.Settings;
  29
  30 import androidx.preference.ListPreference;
  31 import androidx.preference.Preference;
  32
  33 import com.android.settings.R;
  34 import com.android.settings.display.DarkUIPreferenceController;
  35 import com.android.settings.testutils.XmlTestUtils;
  36
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.junit.runner.RunWith;
  40 import org.mockito.MockitoAnnotations;
  41 import org.robolectric.RobolectricTestRunner;
  42 import org.robolectric.RuntimeEnvironment;
  43
  44 import java.util.List;
  45
  46 @RunWith(RobolectricTestRunner.class)
  47 public class AccessibilitySettingsTest {
  48     private static final String VIBRATION_PREFERENCE_SCREEN = "vibration_preference_screen";
  49     private static final String ACCESSIBILITY_CONTENT_TIMEOUT_PREFERENCE =
  50             "accessibility_content_timeout_preference_fragment";
  51     private static final String ACCESSIBILITY_CONTROL_TIMEOUT_PREFERENCE =
  52             "accessibility_control_timeout_preference_fragment";
  53     private static final String DARK_UI_MODE_PREFERENCE =
  54             "dark_ui_mode_accessibility";
  55
  56     private Context mContext;
  57     private ContentResolver mContentResolver;
  58     private AccessibilitySettings mSettings;
  59     private UiModeManager mUiModeManager;
  60
  61     @Before
  62     public void setup() {
  63         MockitoAnnotations.initMocks(this);
  64         mContext = RuntimeEnvironment.application;
  65         mContentResolver = mContext.getContentResolver();
  66         mSettings = spy(new AccessibilitySettings());
  67         doReturn(mContext).when(mSettings).getContext();
  68         mUiModeManager = mContext.getSystemService(UiModeManager.class);
  69     }
  70
  71     @Test
  72     public void testNonIndexableKeys_existInXmlLayout() {
  73         final List<String> niks = AccessibilitySettings.SEARCH_INDEX_DATA_PROVIDER
  74             .getNonIndexableKeys(mContext);
  75         final List<String> keys =
  76             XmlTestUtils.getKeysFromPreferenceXml(mContext, R.xml.accessibility_settings);
  77
  78         assertThat(keys).containsAllIn(niks);
  79     }
  80
  81     @Test
  82     public void testUpdateVibrationSummary_shouldUpdateSummary() {
  83         final Preference vibrationPreferenceScreen = new Preference(mContext);
  84         doReturn(vibrationPreferenceScreen).when(mSettings).findPreference(
  85                 VIBRATION_PREFERENCE_SCREEN);
  86
  87         vibrationPreferenceScreen.setKey(VIBRATION_PREFERENCE_SCREEN);
  88
  89         Settings.System.putInt(mContext.getContentResolver(),
  90                 Settings.System.NOTIFICATION_VIBRATION_INTENSITY,
  91                 Vibrator.VIBRATION_INTENSITY_OFF);
  92
  93         Settings.System.putInt(mContext.getContentResolver(),
  94                 Settings.System.HAPTIC_FEEDBACK_INTENSITY,
  95                 Vibrator.VIBRATION_INTENSITY_OFF);
  96
  97         mSettings.updateVibrationSummary(vibrationPreferenceScreen);
  98         assertThat(vibrationPreferenceScreen.getSummary()).isEqualTo(
  99                 VibrationIntensityPreferenceController.getIntensityString(mContext,
 100                         Vibrator.VIBRATION_INTENSITY_OFF));
 101     }
 102
 103     @Test
 104     public void testUpdateAccessibilityTimeoutSummary_shouldUpdateSummary() {
 105         String[] testingValues = {null, "0", "10000", "30000", "60000", "120000"};
 106         int[] exceptedResIds = {R.string.accessibility_timeout_default,
 107                 R.string.accessibility_timeout_default,
 108                 R.string.accessibility_timeout_10secs,
 109                 R.string.accessibility_timeout_30secs,
 110                 R.string.accessibility_timeout_1min,
 111                 R.string.accessibility_timeout_2mins
 112         };
 113
 114         for (int i = 0; i < testingValues.length; i++) {
 115             Settings.Secure.putString(mContentResolver,
 116                     Settings.Secure.ACCESSIBILITY_NON_INTERACTIVE_UI_TIMEOUT_MS, testingValues[i]);
 117
 118             verifyAccessibilityTimeoutSummary(ACCESSIBILITY_CONTENT_TIMEOUT_PREFERENCE,
 119                     exceptedResIds[i]);
 120
 121             Settings.Secure.putString(mContentResolver,
 122                     Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, testingValues[i]);
 123
 124             verifyAccessibilityTimeoutSummary(ACCESSIBILITY_CONTROL_TIMEOUT_PREFERENCE,
 125                     exceptedResIds[i]);
 126         }
 127     }
 128
 129     @Test
 130     public void testUpdateAccessibilityControlTimeoutSummary_invalidData_shouldUpdateSummary() {
 131         String[] testingValues = {"-9009", "98277466643738977979666555536362343", "Hello,a prank"};
 132
 133         for (String value : testingValues) {
 134             Settings.Secure.putString(mContentResolver,
 135                     Settings.Secure.ACCESSIBILITY_NON_INTERACTIVE_UI_TIMEOUT_MS, value);
 136
 137             verifyAccessibilityTimeoutSummary(ACCESSIBILITY_CONTROL_TIMEOUT_PREFERENCE,
 138                     R.string.accessibility_timeout_default);
 139
 140             Settings.Secure.putString(mContentResolver,
 141                     Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, value);
 142
 143             verifyAccessibilityTimeoutSummary(ACCESSIBILITY_CONTROL_TIMEOUT_PREFERENCE,
 144                     R.string.accessibility_timeout_default);
 145         }
 146     }
 147
 148     private void verifyAccessibilityTimeoutSummary(String preferenceKey, int resId) {
 149         final Preference preference = new Preference(mContext);
 150         doReturn(preference).when(mSettings).findPreference(preferenceKey);
 151         preference.setKey(preferenceKey);
 152         mSettings.updateAccessibilityTimeoutSummary(mContentResolver, preference);
 153
 154         assertThat(preference.getSummary()).isEqualTo(mContext.getResources().getString(resId));
 155     }
 156
 157     @Test
 158     public void testDarkUIModePreferenceSummary_shouldUpdateSummary() {
 159         final ListPreference darkUIModePreference = new ListPreference(mContext);
 160         final DarkUIPreferenceController mController;
 161         doReturn(darkUIModePreference).when(mSettings).findPreference(
 162             DARK_UI_MODE_PREFERENCE);
 163         mController = new DarkUIPreferenceController(mContext, DARK_UI_MODE_PREFERENCE);
 164         final String darkUIModeDescription = modeToDescription(mUiModeManager.getNightMode());
 165         darkUIModePreference.setSummary(mController.getSummary());
 166
 167         assertThat(darkUIModePreference.getSummary()).isEqualTo(darkUIModeDescription);
 168     }
 169
 170     private String modeToDescription(int mode) {
 171         String[] values = mContext.getResources().getStringArray(R.array.dark_ui_mode_entries);
 172         switch (mode) {
 173             case UiModeManager.MODE_NIGHT_YES:
 174                 return values[0];
 175             case UiModeManager.MODE_NIGHT_NO:
 176             case UiModeManager.MODE_NIGHT_AUTO:
 177             default:
 178                 return values[1];
 179         }
 180     }
 181 }