diff --git a/proguard.flags b/proguard.flags index 091211d1327..21c5cfda9cd 100644 --- a/proguard.flags +++ b/proguard.flags @@ -4,6 +4,15 @@ # Keep all Fragments in this package, which are used by reflection. -keep public class com.android.settings.** extends android.app.Fragment +# Keep all preference controllers needed by slice and DashboardFragment. +-keep class * extends com.android.settings.core.BasePreferenceController { + *; +} + +-keep class * extends com.android.settings.core.TogglePreferenceController { + *; +} + # We want to keep methods in Activity that could be used in the XML attribute onClick. -keepclassmembers class * extends android.app.Activity { public void *(android.view.View); diff --git a/src/com/android/settings/bluetooth/BluetoothDetailsMacAddressController.java b/src/com/android/settings/bluetooth/BluetoothDetailsMacAddressController.java index dbcc5d6c7fb..b976561b720 100644 --- a/src/com/android/settings/bluetooth/BluetoothDetailsMacAddressController.java +++ b/src/com/android/settings/bluetooth/BluetoothDetailsMacAddressController.java @@ -45,14 +45,18 @@ public class BluetoothDetailsMacAddressController extends BluetoothDetailsContro protected void init(PreferenceScreen screen) { mFooterPreference = mFooterPreferenceMixin.createFooterPreference(); mFooterPreference.setTitle(mContext.getString( - R.string.bluetooth_device_mac_address, mCachedDevice.getAddress())); + R.string.bluetooth_device_mac_address, mCachedDevice.getAddress())); } @Override - protected void refresh() {} + protected void refresh() { + } @Override public String getPreferenceKey() { + if (mFooterPreference == null) { + return null; + } return mFooterPreference.getKey(); } } diff --git a/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment.java b/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment.java index e9ae11ef408..288c544400f 100644 --- a/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment.java +++ b/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment.java @@ -119,15 +119,7 @@ public class ConnectedDeviceDashboardFragment extends DashboardFragment { @Override public List getNonIndexableKeys(Context context) { - return new ArrayList<>(); } - - @Override - public List getPreferenceControllers( - Context context) { - //TODO(b/69333961): update the index for controllers - return super.getPreferenceControllers(context); - } }; } diff --git a/src/com/android/settings/core/BasePreferenceController.java b/src/com/android/settings/core/BasePreferenceController.java index 1bbee0c47a9..76250fa700c 100644 --- a/src/com/android/settings/core/BasePreferenceController.java +++ b/src/com/android/settings/core/BasePreferenceController.java @@ -116,6 +116,9 @@ public abstract class BasePreferenceController extends AbstractPreferenceControl public BasePreferenceController(Context context, String preferenceKey) { super(context); mPreferenceKey = preferenceKey; + if (TextUtils.isEmpty(mPreferenceKey)) { + throw new IllegalArgumentException("Preference key must be set"); + } } /** diff --git a/src/com/android/settings/core/PreferenceControllerListHelper.java b/src/com/android/settings/core/PreferenceControllerListHelper.java new file mode 100644 index 00000000000..220bd88149d --- /dev/null +++ b/src/com/android/settings/core/PreferenceControllerListHelper.java @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2018 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.core; + +import static com.android.settings.core.PreferenceXmlParserUtils.METADATA_CONTROLLER; +import static com.android.settings.core.PreferenceXmlParserUtils.METADATA_KEY; + +import android.annotation.NonNull; +import android.annotation.XmlRes; +import android.content.Context; +import android.os.Bundle; +import android.text.TextUtils; +import android.util.Log; + +import com.android.settingslib.core.AbstractPreferenceController; + +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.TreeSet; + +/** + * Helper to load {@link BasePreferenceController} lists from Xml. + */ +public class PreferenceControllerListHelper { + + private static final String TAG = "PrefCtrlListCreator"; + + /** + * Instantiates a list of controller based on xml definition. + */ + @NonNull + public static List getPreferenceControllersFromXml(Context context, + @XmlRes int xmlResId) { + final List controllers = new ArrayList<>(); + List preferenceMetadata; + try { + preferenceMetadata = PreferenceXmlParserUtils.extractMetadata(context, xmlResId); + } catch (IOException | XmlPullParserException e) { + Log.e(TAG, "Failed to parse preference xml for getting controllers"); + return controllers; + } + + for (Bundle metadata : preferenceMetadata) { + final String controllerName = metadata.getString(METADATA_CONTROLLER); + if (TextUtils.isEmpty(controllerName)) { + continue; + } + BasePreferenceController controller; + try { + controller = BasePreferenceController.createInstance(context, controllerName); + } catch (IllegalStateException e) { + final String key = metadata.getString(METADATA_KEY); + if (TextUtils.isEmpty(key)) { + Log.w(TAG, "Controller requires key but it's not defined in xml: " + + controllerName); + continue; + } + Log.d(TAG, "Could not find Context-only controller for pref: " + key); + controller = BasePreferenceController.createInstance(context, controllerName, key); + } + controllers.add(controller); + } + return controllers; + } + + /** + * Return a sub list of {@link AbstractPreferenceController} to only contain controller that + * doesn't exist in filter. + * + * @param filter The filter. This list will be unchanged. + * @param input This list will be filtered into a sublist and element is kept + * IFF the controller key is not used by anything from {@param filter}. + */ + @NonNull + public static List filterControllers( + @NonNull List input, + List filter) { + if (input == null || filter == null) { + return input; + } + final Set keys = new TreeSet<>(); + final List filteredList = new ArrayList<>(); + for (AbstractPreferenceController controller : filter) { + final String key = controller.getPreferenceKey(); + if (key != null) { + keys.add(key); + } + } + for (BasePreferenceController controller : input) { + if (keys.contains(controller.getPreferenceKey())) { + Log.w(TAG, controller.getPreferenceKey() + " already has a controller"); + continue; + } + filteredList.add(controller); + } + return filteredList; + } + +} diff --git a/src/com/android/settings/core/PreferenceXmlParserUtils.java b/src/com/android/settings/core/PreferenceXmlParserUtils.java index 4d6e84069d9..e07ca9bd5cd 100644 --- a/src/com/android/settings/core/PreferenceXmlParserUtils.java +++ b/src/com/android/settings/core/PreferenceXmlParserUtils.java @@ -16,18 +16,40 @@ package com.android.settings.core; +import android.annotation.NonNull; import android.annotation.Nullable; import android.content.Context; import android.content.res.TypedArray; +import android.content.res.XmlResourceParser; +import android.os.Bundle; import android.util.AttributeSet; +import android.util.Log; import android.util.TypedValue; +import android.util.Xml; + import com.android.settings.R; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + /** * Utility class to parse elements of XML preferences */ public class PreferenceXmlParserUtils { + private static final String TAG = "PreferenceXmlParserUtil"; + + private static final List SUPPORTED_PREF_TYPES = Arrays.asList( + "Preference", "PreferenceCategory", "PreferenceScreen"); + + public static final String METADATA_KEY = "key"; + public static final String METADATA_CONTROLLER = "controller"; + private static final String ENTRIES_SEPARATOR = "|"; public static String getDataKey(Context context, AttributeSet attrs) { @@ -82,6 +104,47 @@ public class PreferenceXmlParserUtils { return dataIcon; } + /** + * Extracts metadata from preference xml and put them into a {@link Bundle}. + * + * TODO(zhfan): Similar logic exists in {@link SliceBuilderUtils} and + * {@link UniquePreferenceTest}. Need refactoring to consolidate them all. + */ + @NonNull + public static List extractMetadata(Context context, int xmlResId) + throws IOException, XmlPullParserException { + final List metadata = new ArrayList<>(); + if (xmlResId <= 0) { + Log.d(TAG, xmlResId + " is invalid."); + return metadata; + } + final XmlResourceParser parser = context.getResources().getXml(xmlResId); + + int type; + while ((type = parser.next()) != XmlPullParser.END_DOCUMENT + && type != XmlPullParser.START_TAG) { + // Parse next until start tag is found + } + final int outerDepth = parser.getDepth(); + + do { + if (type != XmlPullParser.START_TAG) { + continue; + } + final String nodeName = parser.getName(); + if (!SUPPORTED_PREF_TYPES.contains(nodeName) && !nodeName.endsWith("Preference")) { + continue; + } + final Bundle preferenceMetadata = new Bundle(); + final AttributeSet attrs = Xml.asAttributeSet(parser); + preferenceMetadata.putString(METADATA_KEY, getDataKey(context, attrs)); + preferenceMetadata.putString(METADATA_CONTROLLER, getController(context, attrs)); + metadata.add(preferenceMetadata); + } while ((type = parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)); + return metadata; + } + /** * Returns the fragment name if this preference launches a child fragment. */ @@ -98,7 +161,8 @@ public class PreferenceXmlParserUtils { return data; } - private static String getDataEntries(Context context, AttributeSet set, int[] attrs, int resId) { + private static String getDataEntries(Context context, AttributeSet set, int[] attrs, + int resId) { final TypedArray sa = context.obtainStyledAttributes(set, attrs); final TypedValue tv = sa.peekValue(resId); sa.recycle(); @@ -108,7 +172,7 @@ public class PreferenceXmlParserUtils { data = context.getResources().getStringArray(tv.resourceId); } } - final int count = (data == null ) ? 0 : data.length; + final int count = (data == null) ? 0 : data.length; if (count == 0) { return null; } diff --git a/src/com/android/settings/dashboard/DashboardFragment.java b/src/com/android/settings/dashboard/DashboardFragment.java index a4f9a6b8266..8f9f95ad621 100644 --- a/src/com/android/settings/dashboard/DashboardFragment.java +++ b/src/com/android/settings/dashboard/DashboardFragment.java @@ -29,9 +29,13 @@ import android.util.ArraySet; import android.util.Log; import com.android.settings.SettingsPreferenceFragment; +import com.android.settings.core.BasePreferenceController; +import com.android.settings.core.PreferenceControllerListHelper; import com.android.settings.overlay.FeatureFactory; import com.android.settings.search.Indexable; import com.android.settingslib.core.AbstractPreferenceController; +import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.drawer.DashboardCategory; import com.android.settingslib.drawer.SettingsDrawerActivity; import com.android.settingslib.drawer.Tile; @@ -63,13 +67,34 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment @Override public void onAttach(Context context) { super.onAttach(context); - mDashboardFeatureProvider = - FeatureFactory.getFactory(context).getDashboardFeatureProvider(context); + mDashboardFeatureProvider = FeatureFactory.getFactory(context). + getDashboardFeatureProvider(context); + final List controllers = new ArrayList<>(); + // Load preference controllers from code + final List controllersFromCode = + getPreferenceControllers(context); + // Load preference controllers from xml definition + final List controllersFromXml = PreferenceControllerListHelper + .getPreferenceControllersFromXml(context, getPreferenceScreenResId()); + // Filter xml-based controllers in case a similar controller is created from code already. + final List uniqueControllerFromXml = + PreferenceControllerListHelper.filterControllers( + controllersFromXml, controllersFromCode); - List controllers = getPreferenceControllers(context); - if (controllers == null) { - controllers = new ArrayList<>(); + // Add unique controllers to list. + if (controllersFromCode != null) { + controllers.addAll(controllersFromCode); } + controllers.addAll(uniqueControllerFromXml); + + // And wire up with lifecycle. + final Lifecycle lifecycle = getLifecycle(); + uniqueControllerFromXml + .stream() + .filter(controller -> controller instanceof LifecycleObserver) + .forEach( + controller -> lifecycle.addObserver((LifecycleObserver) controller)); + mPlaceholderPreferenceController = new DashboardTilePlaceholderPreferenceController(context); controllers.add(mPlaceholderPreferenceController); @@ -217,7 +242,9 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment /** * Get a list of {@link AbstractPreferenceController} for this fragment. */ - protected abstract List getPreferenceControllers(Context context); + protected List getPreferenceControllers(Context context) { + return null; + } /** * Returns true if this tile should be displayed @@ -327,7 +354,7 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment final Context context = getContext(); mSummaryLoader = new SummaryLoader(getActivity(), getCategoryKey()); mSummaryLoader.setSummaryConsumer(this); - final TypedArray a = context.obtainStyledAttributes(new int[]{ + final TypedArray a = context.obtainStyledAttributes(new int[] { android.R.attr.colorControlNormal}); final int tintColor = a.getColor(0, context.getColor(android.R.color.white)); a.recycle(); diff --git a/src/com/android/settings/search/BaseSearchIndexProvider.java b/src/com/android/settings/search/BaseSearchIndexProvider.java index f75aa85a1fb..d7577b5fc37 100644 --- a/src/com/android/settings/search/BaseSearchIndexProvider.java +++ b/src/com/android/settings/search/BaseSearchIndexProvider.java @@ -28,6 +28,7 @@ import android.util.Log; import android.util.Xml; import com.android.settings.core.BasePreferenceController; +import com.android.settings.core.PreferenceControllerListHelper; import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.core.PreferenceXmlParserUtils; import com.android.settingslib.core.AbstractPreferenceController; @@ -66,7 +67,7 @@ public class BaseSearchIndexProvider implements Indexable.SearchIndexProvider { // Entire page should be suppressed, mark all keys from this page as non-indexable. return getNonIndexableKeysFromXml(context); } - final List controllers = getPreferenceControllers(context); + final List controllers = getAllPreferenceControllers(context); if (controllers != null && !controllers.isEmpty()) { final List nonIndexableKeys = new ArrayList<>(); for (AbstractPreferenceController controller : controllers) { @@ -88,6 +89,28 @@ public class BaseSearchIndexProvider implements Indexable.SearchIndexProvider { } @Override + public List getAllPreferenceControllers(Context context) { + final List controllersFromCode = + getPreferenceControllers(context); + final List res = getXmlResourcesToIndex(context, true); + if (res == null || res.isEmpty()) { + return controllersFromCode; + } + List controllersFromXml = new ArrayList<>(); + for (SearchIndexableResource sir : res) { + controllersFromXml.addAll(PreferenceControllerListHelper + .getPreferenceControllersFromXml(context, sir.xmlResId)); + } + controllersFromXml = PreferenceControllerListHelper.filterControllers(controllersFromXml, + controllersFromCode); + final List allControllers = new ArrayList<>(); + if (controllersFromCode != null) { + allControllers.addAll(controllersFromCode); + } + allControllers.addAll(controllersFromXml); + return allControllers; + } + public List getPreferenceControllers(Context context) { return null; } diff --git a/src/com/android/settings/search/DatabaseIndexingUtils.java b/src/com/android/settings/search/DatabaseIndexingUtils.java index c7c23202a9b..addc8079758 100644 --- a/src/com/android/settings/search/DatabaseIndexingUtils.java +++ b/src/com/android/settings/search/DatabaseIndexingUtils.java @@ -77,8 +77,7 @@ public class DatabaseIndexingUtils { * @return A map between {@link Uri}s and {@link PreferenceControllerMixin}s to get the payload * types for Settings. */ - public static Map getPayloadKeyMap( - String className, Context context) { + public static Map getPayloadKeyMap(String className, Context context) { ArrayMap map = new ArrayMap<>(); if (context == null) { return map; @@ -96,8 +95,8 @@ public class DatabaseIndexingUtils { // SEARCH_INDEX_DATA_PROVIDER field final Indexable.SearchIndexProvider provider = getSearchIndexProvider(clazz); - List controllers = - provider.getPreferenceControllers(context); + final List controllers = + provider.getAllPreferenceControllers(context); if (controllers == null) { return map; diff --git a/src/com/android/settings/search/Indexable.java b/src/com/android/settings/search/Indexable.java index 505f41b4001..3b2017dd164 100644 --- a/src/com/android/settings/search/Indexable.java +++ b/src/com/android/settings/search/Indexable.java @@ -18,7 +18,7 @@ package com.android.settings.search; import android.content.Context; import android.provider.SearchIndexableResource; -import com.android.settings.core.PreferenceControllerMixin; + import com.android.settingslib.core.AbstractPreferenceController; import java.util.List; @@ -72,7 +72,9 @@ public interface Indexable { * @param context * @return a list of {@link AbstractPreferenceController} for ResultPayload data during * Indexing. + * + * TODO(zhfan): name is confusing(too similar to getPreferenceControllers). Rename both. */ - List getPreferenceControllers(Context context); + List getAllPreferenceControllers(Context context); } } diff --git a/src/com/android/settings/system/SystemDashboardFragment.java b/src/com/android/settings/system/SystemDashboardFragment.java index deabf543b3a..1556659fa8e 100644 --- a/src/com/android/settings/system/SystemDashboardFragment.java +++ b/src/com/android/settings/system/SystemDashboardFragment.java @@ -26,12 +26,9 @@ import com.android.internal.logging.nano.MetricsProto; import com.android.settings.R; import com.android.settings.backup.BackupSettingsActivityPreferenceController; import com.android.settings.dashboard.DashboardFragment; -import com.android.settings.gestures.GesturesSettingPreferenceController; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settings.search.Indexable; -import com.android.settingslib.core.AbstractPreferenceController; -import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -72,20 +69,6 @@ public class SystemDashboardFragment extends DashboardFragment { return R.string.help_url_system_dashboard; } - @Override - protected List getPreferenceControllers(Context context) { - return buildPreferenceControllers(context); - } - - private static List buildPreferenceControllers(Context context) { - final List controllers = new ArrayList<>(); - controllers.add(new SystemUpdatePreferenceController(context)); - controllers.add(new AdditionalSystemUpdatePreferenceController(context)); - controllers.add(new BackupSettingsActivityPreferenceController(context)); - controllers.add(new GesturesSettingPreferenceController(context)); - return controllers; - } - private int getVisiblePreferenceCount(PreferenceGroup group) { int visibleCount = 0; for (int i = 0; i < group.getPreferenceCount(); i++) { @@ -112,12 +95,6 @@ public class SystemDashboardFragment extends DashboardFragment { return Arrays.asList(sir); } - @Override - public List getPreferenceControllers( - Context context) { - return buildPreferenceControllers(context); - } - @Override public List getNonIndexableKeys(Context context) { List keys = super.getNonIndexableKeys(context); diff --git a/tests/robotests/assets/grandfather_not_in_search_index_provider_registry b/tests/robotests/assets/grandfather_not_in_search_index_provider_registry index 666b224558a..948b14ad70c 100644 --- a/tests/robotests/assets/grandfather_not_in_search_index_provider_registry +++ b/tests/robotests/assets/grandfather_not_in_search_index_provider_registry @@ -1,2 +1 @@ com.android.settings.display.ScreenZoomPreferenceFragmentForSetupWizard -com.android.settings.search.indexing.FakeSettingsFragment \ No newline at end of file diff --git a/tests/robotests/assets/grandfather_not_sharing_pref_controllers_with_search_provider b/tests/robotests/assets/grandfather_not_sharing_pref_controllers_with_search_provider index a71b040b080..da541e21df2 100644 --- a/tests/robotests/assets/grandfather_not_sharing_pref_controllers_with_search_provider +++ b/tests/robotests/assets/grandfather_not_sharing_pref_controllers_with_search_provider @@ -1 +1,5 @@ -com.android.settings.fuelgauge.PowerUsageSummary \ No newline at end of file +com.android.settings.datausage.DataUsageSummaryLegacy +com.android.settings.fuelgauge.PowerUsageSummary +com.android.settings.fuelgauge.PowerUsageAdvanced +com.android.settings.search.indexing.FakeSettingsFragment +com.android.settings.system.SystemDashboardFragment \ No newline at end of file diff --git a/tests/robotests/res/xml-mcc999/location_settings.xml b/tests/robotests/res/xml-mcc999/location_settings.xml index de77bfae006..5619c774a6d 100644 --- a/tests/robotests/res/xml-mcc999/location_settings.xml +++ b/tests/robotests/res/xml-mcc999/location_settings.xml @@ -17,7 +17,8 @@ + android:title="screen_title" + settings:controller="com.android.settings.slices.FakePreferenceController"> indexRes = - mFragment.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex(mContext, + mFragment.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex( + RuntimeEnvironment.application, true /* enabled */); assertThat(indexRes).isNotNull(); @@ -81,9 +70,8 @@ public class AdvancedConnectedDeviceDashboardFragmentTest { @Test public void testNonIndexableKeys_existInXmlLayout() { final Context context = RuntimeEnvironment.application; - when(mManager.hasSystemFeature(PackageManager.FEATURE_NFC)).thenReturn(false); final List niks = ConnectedDeviceDashboardFragment.SEARCH_INDEX_DATA_PROVIDER - .getNonIndexableKeys(mContext); + .getNonIndexableKeys(context); final int xmlId = (new ConnectedDeviceDashboardFragment()).getPreferenceScreenResId(); final List keys = XmlTestUtils.getKeysFromPreferenceXml(context, xmlId); diff --git a/tests/robotests/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment2Test.java b/tests/robotests/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment2Test.java deleted file mode 100644 index 5aa39338fb2..00000000000 --- a/tests/robotests/src/com/android/settings/connecteddevice/ConnectedDeviceDashboardFragment2Test.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * Copyright (C) 2016 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.connecteddevice; - -import static android.content.Context.NFC_SERVICE; -import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; -import static org.mockito.Mockito.when; - -import android.content.Context; -import android.content.pm.PackageManager; -import android.nfc.NfcAdapter; -import android.nfc.NfcManager; -import android.provider.SearchIndexableResource; - -import com.android.settings.R; -import com.android.settings.TestConfig; -import com.android.settings.core.PreferenceControllerMixin; -import com.android.settings.dashboard.SummaryLoader; -import com.android.settings.nfc.NfcPreferenceController; -import com.android.settings.testutils.FakeFeatureFactory; -import com.android.settings.testutils.SettingsRobolectricTestRunner; -import com.android.settings.testutils.XmlTestUtils; -import com.android.settingslib.drawer.CategoryKey; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Answers; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.robolectric.RuntimeEnvironment; -import org.robolectric.annotation.Config; - -import java.util.List; - -@RunWith(SettingsRobolectricTestRunner.class) -@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) -public class ConnectedDeviceDashboardFragment2Test { - - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - Context mContext; - - @Mock - private PackageManager mManager; - - private FakeFeatureFactory mFeatureFactory; - private ConnectedDeviceDashboardFragmentOld mFragment; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - mFeatureFactory = FakeFeatureFactory.setupForTest(); - - mFragment = new ConnectedDeviceDashboardFragmentOld(); - when(mContext.getPackageManager()).thenReturn(mManager); - } - - @Test - public void testSearchIndexProvider_shouldIndexResource() { - final List indexRes = - mFragment.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex(mContext, - true /* enabled */); - - assertThat(indexRes).isNotNull(); - assertThat(indexRes.get(0).xmlResId).isEqualTo(mFragment.getPreferenceScreenResId()); - } - - @Test - public void testSearchIndexProvider_NoNfc_KeyAdded() { - when(mManager.hasSystemFeature(PackageManager.FEATURE_NFC)).thenReturn(false); - final List keys = mFragment.SEARCH_INDEX_DATA_PROVIDER.getNonIndexableKeys( - mContext); - - assertThat(keys).isNotNull(); - assertThat(keys).contains(NfcPreferenceController.KEY_TOGGLE_NFC); - assertThat(keys).contains(NfcPreferenceController.KEY_ANDROID_BEAM_SETTINGS); - } - - @Test - public void testSearchIndexProvider_NFC_KeyNotAdded() { - when(mManager.hasSystemFeature(PackageManager.FEATURE_NFC)).thenReturn(true); - final List keys = mFragment.SEARCH_INDEX_DATA_PROVIDER.getNonIndexableKeys( - mContext); - - assertThat(keys).isNotNull(); - assertThat(keys).doesNotContain(NfcPreferenceController.KEY_TOGGLE_NFC); - assertThat(keys).doesNotContain(NfcPreferenceController.KEY_ANDROID_BEAM_SETTINGS); - } - - @Test - public void testNonIndexableKeys_existInXmlLayout() { - final Context context = RuntimeEnvironment.application; - when(mManager.hasSystemFeature(PackageManager.FEATURE_NFC)).thenReturn(false); - final List niks = ConnectedDeviceDashboardFragment.SEARCH_INDEX_DATA_PROVIDER - .getNonIndexableKeys(mContext); - final int xmlId = (new ConnectedDeviceDashboardFragment()).getPreferenceScreenResId(); - - final List keys = XmlTestUtils.getKeysFromPreferenceXml(context, xmlId); - - assertThat(keys).containsAllIn(niks); - } - - @Test - public void testSummaryProvider_hasNfc_shouldReturnNfcSummary() { - final NfcManager nfcManager = mock(NfcManager.class); - final SummaryLoader summaryLoader = mock(SummaryLoader.class); - - when(mContext.getApplicationContext()).thenReturn(mContext); - when(mContext.getSystemService(NFC_SERVICE)).thenReturn(nfcManager); - when(nfcManager.getDefaultAdapter()).thenReturn(mock(NfcAdapter.class)); - - SummaryLoader.SummaryProvider provider = - new ConnectedDeviceDashboardFragment.SummaryProvider(mContext, summaryLoader); - - provider.setListening(false); - - verifyZeroInteractions(summaryLoader); - - provider.setListening(true); - - verify(mContext).getString(R.string.connected_devices_dashboard_summary); - } - - @Test - public void testSummaryProvider_noNfc_shouldReturnNoNfcSummary() { - final SummaryLoader summaryLoader = mock(SummaryLoader.class); - - when(mContext.getApplicationContext()).thenReturn(mContext); - when(mContext.getSystemService(NFC_SERVICE)).thenReturn(null); - - SummaryLoader.SummaryProvider provider = - new ConnectedDeviceDashboardFragment.SummaryProvider(mContext, summaryLoader); - - provider.setListening(false); - - verifyZeroInteractions(summaryLoader); - - provider.setListening(true); - - verify(mContext).getString(R.string.connected_devices_dashboard_no_nfc_summary); - } -} diff --git a/tests/robotests/src/com/android/settings/core/BasePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/core/BasePreferenceControllerTest.java index c0ac961e07e..3c0740b4f36 100644 --- a/tests/robotests/src/com/android/settings/core/BasePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/core/BasePreferenceControllerTest.java @@ -31,6 +31,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; @RunWith(SettingsRobolectricTestRunner.class) @@ -45,6 +46,17 @@ public class BasePreferenceControllerTest { MockitoAnnotations.initMocks(this); } + + @Test(expected = IllegalArgumentException.class) + public void newController_noKey_shouldCrash() { + new BasePreferenceController(RuntimeEnvironment.application, null /* key */) { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }; + } + @Test public void isAvailable_availableStatusAvailable_returnsTrue() { when(mPreferenceController.getAvailabilityStatus()).thenReturn(AVAILABLE); diff --git a/tests/robotests/src/com/android/settings/core/PreferenceControllerListHelperTest.java b/tests/robotests/src/com/android/settings/core/PreferenceControllerListHelperTest.java new file mode 100644 index 00000000000..c0bc3ef295e --- /dev/null +++ b/tests/robotests/src/com/android/settings/core/PreferenceControllerListHelperTest.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2018 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.core; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; + +import com.android.settings.R; +import com.android.settings.TestConfig; +import com.android.settings.slices.FakePreferenceController; +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settingslib.core.AbstractPreferenceController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.annotation.Config; + +import java.util.ArrayList; +import java.util.List; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class PreferenceControllerListHelperTest { + + private Context mContext; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + } + + @Test + @Config(qualifiers = "mcc999") + public void getControllers_shouldReturnAList() { + final List controllers = + PreferenceControllerListHelper.getPreferenceControllersFromXml(mContext, + R.xml.location_settings); + + assertThat(controllers).isNotEmpty(); + for (BasePreferenceController controller : controllers) { + assertThat(controller).isInstanceOf(FakePreferenceController.class); + } + } + + @Test + public void filterControllers_noFilter_shouldReturnSameList() { + final List controllers = new ArrayList<>(); + controllers.add(new BasePreferenceController(mContext, "key") { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }); + final List result = PreferenceControllerListHelper + .filterControllers(controllers, null /* filter */); + assertThat(result).containsExactlyElementsIn(controllers); + } + + @Test + public void filterControllers_noDuplicationFromFilter_shouldReturnSameList() { + final List controllers = new ArrayList<>(); + controllers.add(new BasePreferenceController(mContext, "key") { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }); + final List filter = new ArrayList<>(); + filter.add(new BasePreferenceController(mContext, "key2") { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }); + final List result = PreferenceControllerListHelper + .filterControllers(controllers, filter); + assertThat(result).containsExactlyElementsIn(controllers); + } + + @Test + public void filterControllers_hasDuplicationFromFilter_shouldReturnSameList() { + final List controllers = new ArrayList<>(); + controllers.add(new BasePreferenceController(mContext, "key") { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }); + final List filter = new ArrayList<>(); + filter.add(new BasePreferenceController(mContext, "key") { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }); + final List result = PreferenceControllerListHelper + .filterControllers(controllers, filter); + assertThat(result).isEmpty(); + } + +} diff --git a/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentSearchIndexProviderInspector.java b/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentSearchIndexProviderInspector.java index 3d9783da2ed..e5db16ed6ec 100644 --- a/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentSearchIndexProviderInspector.java +++ b/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentSearchIndexProviderInspector.java @@ -50,7 +50,7 @@ public class DashboardFragmentSearchIndexProviderInspector { final List controllersFromSearchIndexProvider; final List controllersFromFragment; try { - controllersFromSearchIndexProvider = provider.getPreferenceControllers(context); + controllersFromSearchIndexProvider = provider.getAllPreferenceControllers(context); } catch (Throwable e) { // Can't do much with exception, assume the test passed. return true; diff --git a/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java b/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java index 40e590a665c..f16c4a4a4c2 100644 --- a/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java +++ b/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java @@ -19,6 +19,8 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.nullable; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -44,11 +46,10 @@ import com.android.settingslib.drawer.TileUtils; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Answers; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; -import org.robolectric.shadows.ShadowApplication; import org.robolectric.util.ReflectionHelpers; import java.util.ArrayList; @@ -58,24 +59,25 @@ import java.util.List; @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) public class DashboardFragmentTest { - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - private Context mContext; + @Mock private FakeFeatureFactory mFakeFeatureFactory; private DashboardCategory mDashboardCategory; + private Context mContext; private TestFragment mTestFragment; @Before public void setUp() { MockitoAnnotations.initMocks(this); + mContext = spy(RuntimeEnvironment.application); mFakeFeatureFactory = FakeFeatureFactory.setupForTest(); mDashboardCategory = new DashboardCategory(); mDashboardCategory.addTile(new Tile()); - mTestFragment = new TestFragment(ShadowApplication.getInstance().getApplicationContext()); + mTestFragment = new TestFragment(mContext); when(mFakeFeatureFactory.dashboardFeatureProvider .getTilesForCategory(nullable(String.class))) .thenReturn(mDashboardCategory); - mTestFragment.onAttach(ShadowApplication.getInstance().getApplicationContext()); + mTestFragment.onAttach(mContext); when(mContext.getPackageName()).thenReturn("TestPackage"); } @@ -146,16 +148,18 @@ public class DashboardFragmentTest { mock(AbstractPreferenceController.class); final AbstractPreferenceController mockController2 = mock(AbstractPreferenceController.class); + when(mockController1.getPreferenceKey()).thenReturn("key1"); + when(mockController2.getPreferenceKey()).thenReturn("key2"); preferenceControllers.add(mockController1); preferenceControllers.add(mockController2); when(mockController1.isAvailable()).thenReturn(false); when(mockController2.isAvailable()).thenReturn(true); - mTestFragment.onAttach(ShadowApplication.getInstance().getApplicationContext()); + mTestFragment.onAttach(mContext); mTestFragment.onResume(); - verify(mockController1, never()).getPreferenceKey(); - verify(mockController2).getPreferenceKey(); + verify(mockController1).getPreferenceKey(); + verify(mockController2, times(2)).getPreferenceKey(); } @Test @@ -205,9 +209,7 @@ public class DashboardFragmentTest { final Intent intent = new Intent(); tile.intent = intent; - intent.setComponent(new ComponentName( - ShadowApplication.getInstance().getApplicationContext().getPackageName(), - "TestClass")); + intent.setComponent(new ComponentName(mContext.getPackageName(), "TestClass")); assertThat(mTestFragment.tintTileIcon(tile)).isFalse(); intent.setComponent(new ComponentName("OtherPackage", "TestClass")); diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java index b38b0f09c2e..b46be8c9373 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java @@ -98,7 +98,7 @@ public final class EnterprisePrivacySettingsTest { @Test public void getSearchIndexProviderPreferenceControllers() throws Exception { final List controllers - = EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers( + = EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getAllPreferenceControllers( ShadowApplication.getInstance().getApplicationContext()); verifyPreferenceControllers(controllers); } diff --git a/tests/robotests/src/com/android/settings/search/BaseSearchIndexProviderTest.java b/tests/robotests/src/com/android/settings/search/BaseSearchIndexProviderTest.java index 260e3ae062d..798149ad8e8 100644 --- a/tests/robotests/src/com/android/settings/search/BaseSearchIndexProviderTest.java +++ b/tests/robotests/src/com/android/settings/search/BaseSearchIndexProviderTest.java @@ -18,7 +18,6 @@ package com.android.settings.search; import static com.google.common.truth.Truth.assertThat; - import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; @@ -26,15 +25,15 @@ import android.content.Context; import android.provider.SearchIndexableResource; import com.android.settings.R; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.core.BasePreferenceController; import com.android.settings.core.PreferenceControllerMixin; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settingslib.core.AbstractPreferenceController; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; @@ -50,13 +49,13 @@ public class BaseSearchIndexProviderTest { private static final String TEST_PREF_KEY = "test_pref_key"; - @Mock private Context mContext; private BaseSearchIndexProvider mIndexProvider; @Before public void setUp() { MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; mIndexProvider = spy(BaseSearchIndexProvider.class); } @@ -91,6 +90,38 @@ public class BaseSearchIndexProviderTest { assertThat(mIndexProvider.getNonIndexableKeys(mContext)).isEqualTo(Collections.EMPTY_LIST); } + @Test + @Config(qualifiers = "mcc999") + public void getAllPreferenceControllers_shouldCreateControllerFromCodeAndXml() { + + final BaseSearchIndexProvider provider = new BaseSearchIndexProvider() { + @Override + public List getXmlResourcesToIndex(Context context, + boolean enabled) { + final SearchIndexableResource sir = new SearchIndexableResource(context); + sir.xmlResId = R.xml.location_settings; + return Arrays.asList(sir); + } + + @Override + public List getPreferenceControllers(Context context) { + final List controllersFromCode = new ArrayList<>(); + controllersFromCode.add(new BasePreferenceController(mContext, "TEST_KEY") { + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + }); + return controllersFromCode; + } + }; + + final List controllers = + provider.getAllPreferenceControllers(mContext); + + assertThat(controllers).hasSize(3); + } + public static class NotAvailablePreferenceController extends AbstractPreferenceController implements PreferenceControllerMixin { public NotAvailablePreferenceController(Context context) { diff --git a/tests/robotests/src/com/android/settings/search/FakeIndexProvider.java b/tests/robotests/src/com/android/settings/search/FakeIndexProvider.java index 466f5a94f4b..e5f1631b01c 100644 --- a/tests/robotests/src/com/android/settings/search/FakeIndexProvider.java +++ b/tests/robotests/src/com/android/settings/search/FakeIndexProvider.java @@ -21,7 +21,6 @@ import android.content.Context; import android.provider.SearchIndexableResource; import com.android.settings.R; -import com.android.settingslib.core.AbstractPreferenceController; import java.util.ArrayList; import java.util.List; @@ -48,12 +47,6 @@ public class FakeIndexProvider implements Indexable { result.add(KEY); return result; } - - @Override - public List getPreferenceControllers( - Context context) { - return null; - } }; } diff --git a/tests/robotests/src/com/android/settings/search/XmlParserUtilTest.java b/tests/robotests/src/com/android/settings/search/PreferenceXmlParserUtilTest.java similarity index 89% rename from tests/robotests/src/com/android/settings/search/XmlParserUtilTest.java rename to tests/robotests/src/com/android/settings/search/PreferenceXmlParserUtilTest.java index 2d1a232fa47..999e93a252d 100644 --- a/tests/robotests/src/com/android/settings/search/XmlParserUtilTest.java +++ b/tests/robotests/src/com/android/settings/search/PreferenceXmlParserUtilTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.content.Context; import android.content.res.XmlResourceParser; +import android.os.Bundle; import android.util.AttributeSet; import android.util.Xml; @@ -32,9 +33,13 @@ import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; -import org.robolectric.shadows.ShadowApplication; import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; +import java.util.List; /** * These tests use a series of preferences that have specific attributes which are sometimes @@ -45,13 +50,13 @@ import org.xmlpull.v1.XmlPullParser; */ @RunWith(SettingsRobolectricTestRunner.class) @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) -public class XmlParserUtilTest { +public class PreferenceXmlParserUtilTest { private Context mContext; @Before public void setUp() { - mContext = ShadowApplication.getInstance().getApplicationContext(); + mContext = RuntimeEnvironment.application; } @Test @@ -91,7 +96,6 @@ public class XmlParserUtilTest { String summary = PreferenceXmlParserUtils.getDataSummary(mContext, attrs); String expSummary = mContext.getString(R.string.summary_placeholder); assertThat(summary).isEqualTo(expSummary); - } @Test @@ -163,6 +167,20 @@ public class XmlParserUtilTest { assertThat(entries).isNull(); } + @Test + @Config(qualifiers = "mcc999") + public void extractMetadata_shouldContainKeyAndControllerName() + throws IOException, XmlPullParserException { + final List metadata = PreferenceXmlParserUtils.extractMetadata(mContext, + R.xml.location_settings); + + assertThat(metadata).isNotEmpty(); + for (Bundle bundle : metadata) { + assertThat(bundle.getString(PreferenceXmlParserUtils.METADATA_KEY)).isNotNull(); + assertThat(bundle.getString(PreferenceXmlParserUtils.METADATA_CONTROLLER)).isNotNull(); + } + } + /** * @param resId the ID for the XML preference * @return an XML resource parser that points to the start tag diff --git a/tests/robotests/src/com/android/settings/search/SearchIndexableResourcesTest.java b/tests/robotests/src/com/android/settings/search/SearchIndexableResourcesTest.java index 72dd94c2896..5aa2a24fd22 100644 --- a/tests/robotests/src/com/android/settings/search/SearchIndexableResourcesTest.java +++ b/tests/robotests/src/com/android/settings/search/SearchIndexableResourcesTest.java @@ -18,9 +18,8 @@ package com.android.settings.search; import static android.provider.SearchIndexablesContract.COLUMN_INDEX_NON_INDEXABLE_KEYS_KEY_VALUE; import static com.google.common.truth.Truth.assertThat; - import static junit.framework.Assert.fail; - +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; @@ -36,6 +35,7 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; @RunWith(SettingsRobolectricTestRunner.class) @@ -67,7 +67,7 @@ public class SearchIndexableResourcesTest { final int beforeCount = mSearchProvider.getSearchIndexableResources().getProviderValues().size(); - ( (SearchIndexableResourcesImpl) mSearchProvider.getSearchIndexableResources()) + ((SearchIndexableResourcesImpl) mSearchProvider.getSearchIndexableResources()) .addIndex(java.lang.String.class); assertThat(mSearchProvider.getSearchIndexableResources().getProviderValues()) @@ -86,11 +86,13 @@ public class SearchIndexableResourcesTest { @Test public void testNonIndexableKeys_GetsKeyFromProvider() { mSearchProvider.getSearchIndexableResources().getProviderValues().clear(); - ( (SearchIndexableResourcesImpl) mSearchProvider.getSearchIndexableResources()) + ((SearchIndexableResourcesImpl) mSearchProvider.getSearchIndexableResources()) .addIndex(FakeIndexProvider.class); SettingsSearchIndexablesProvider provider = spy(new SettingsSearchIndexablesProvider()); + doReturn(RuntimeEnvironment.application).when(provider).getContext(); + Cursor cursor = provider.queryNonIndexableKeys(null); boolean hasTestKey = false; while (cursor.moveToNext()) { @@ -106,8 +108,8 @@ public class SearchIndexableResourcesTest { @Test public void testAllClassNamesHaveProviders() { - for (Class clazz: mSearchProvider.getSearchIndexableResources().getProviderValues()) { - if(DatabaseIndexingUtils.getSearchIndexProvider(clazz) == null) { + for (Class clazz : mSearchProvider.getSearchIndexableResources().getProviderValues()) { + if (DatabaseIndexingUtils.getSearchIndexProvider(clazz) == null) { fail(clazz.getName() + "is not an index provider"); } } diff --git a/tests/robotests/src/com/android/settings/search/SettingsSearchIndexablesProviderTest.java b/tests/robotests/src/com/android/settings/search/SettingsSearchIndexablesProviderTest.java index cca279481fa..389b0aaf04f 100644 --- a/tests/robotests/src/com/android/settings/search/SettingsSearchIndexablesProviderTest.java +++ b/tests/robotests/src/com/android/settings/search/SettingsSearchIndexablesProviderTest.java @@ -104,6 +104,7 @@ public class SettingsSearchIndexablesProviderTest { } @Test + @Config(qualifiers = "mcc999") public void testNonIndexablesColumnFetched() { Uri rawUri = Uri.parse("content://" + BASE_AUTHORITY + "/" + SearchIndexablesContract.NON_INDEXABLES_KEYS_PATH); diff --git a/tests/robotests/src/com/android/settings/system/FactoryResetPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/system/FactoryResetPreferenceControllerTest.java index b986e4f7f54..f71ae93456c 100644 --- a/tests/robotests/src/com/android/settings/system/FactoryResetPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/system/FactoryResetPreferenceControllerTest.java @@ -16,15 +16,14 @@ package com.android.settings.system; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Answers.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.when; import android.accounts.AccountManager; import android.content.Context; import android.os.UserManager; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.testutils.shadow.ShadowSecureSettings; import com.android.settings.testutils.shadow.ShadowUtils; @@ -34,7 +33,9 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; @RunWith(SettingsRobolectricTestRunner.class) @Config( @@ -46,20 +47,20 @@ public class FactoryResetPreferenceControllerTest { private static final String FACTORY_RESET_KEY = "factory_reset"; - @Mock(answer = RETURNS_DEEP_STUBS) - private Context mContext; @Mock private UserManager mUserManager; @Mock private AccountManager mAccountManager; + private Context mContext; private FactoryResetPreferenceController mController; @Before public void setUp() { MockitoAnnotations.initMocks(this); - when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager); - when(mContext.getSystemService(Context.ACCOUNT_SERVICE)).thenReturn(mAccountManager); + mContext = RuntimeEnvironment.application; + ShadowApplication.getInstance().setSystemService(Context.USER_SERVICE, mUserManager); + ShadowApplication.getInstance().setSystemService(Context.ACCOUNT_SERVICE, mAccountManager); mController = new FactoryResetPreferenceController(mContext); } diff --git a/tests/unit/src/com/android/settings/core/PreferenceControllerContractTest.java b/tests/unit/src/com/android/settings/core/PreferenceControllerContractTest.java index b16c700543a..7e26f1115b7 100644 --- a/tests/unit/src/com/android/settings/core/PreferenceControllerContractTest.java +++ b/tests/unit/src/com/android/settings/core/PreferenceControllerContractTest.java @@ -67,7 +67,7 @@ public class PreferenceControllerContractTest { } final List controllers = - provider.getPreferenceControllers(mContext); + provider.getAllPreferenceControllers(mContext); if (controllers == null) { continue; }