PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove location mode menu from location settings"

Browse Source
This commit is contained in:
TreeHugger Robot
2018-01-25 03:08:06 +00:00
committed by Android (Google) Code Review
parent 7c80b5ed39 5a86cd6545
commit 7ccd083f7b
19 changed files with 9 additions and 984 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
tests/robotests/src/com/android/settings/location/LocationModeBatterySavingPreferenceControllerTest.java
View File

@@ -1,57 +0,0 @@
/*
* Copyright (C) 2017 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.location;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import android.arch.lifecycle.LifecycleOwner;
import android.content.Context;
import android.provider.Settings;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class LocationModeBatterySavingPreferenceControllerTest {
private LifecycleOwner mLifecycleOwner;
private Lifecycle mLifecycle;
@Before
public void setUp() {
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
}
@Test
public void getLocationMode_shouldReturnModeBatterySaving() {
final LocationModeBatterySavingPreferenceController controller =
new LocationModeBatterySavingPreferenceController(mock(Context.class), mLifecycle);
assertThat(controller.getLocationMode())
.isEqualTo(Settings.Secure.LOCATION_MODE_BATTERY_SAVING);
}
}

57
tests/robotests/src/com/android/settings/location/LocationModeHighAccuracyPreferenceControllerTest.java
View File

@@ -1,57 +0,0 @@
/*
* Copyright (C) 2017 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.location;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import android.arch.lifecycle.LifecycleOwner;
import android.content.Context;
import android.provider.Settings;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class LocationModeHighAccuracyPreferenceControllerTest {
private LifecycleOwner mLifecycleOwner;
private Lifecycle mLifecycle;
@Before
public void setUp() {
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
}
@Test
public void getLocationMode_shouldReturnModeHighAccuracy() {
final LocationModeHighAccuracyPreferenceController controller =
new LocationModeHighAccuracyPreferenceController(mock(Context.class), mLifecycle);
assertThat(controller.getLocationMode())
.isEqualTo(Settings.Secure.LOCATION_MODE_HIGH_ACCURACY);
}
}

141
tests/robotests/src/com/android/settings/location/LocationModePreferenceControllerTest.java
View File

@@ -1,141 +0,0 @@
/*
* Copyright (C) 2017 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.location;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.arch.lifecycle.LifecycleOwner;
import android.content.Context;
import android.os.UserManager;
import android.provider.Settings;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.lifecycle.Lifecycle;
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;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class LocationModePreferenceControllerTest {
@Mock
private LocationSettings mFragment;
@Mock
private SettingsActivity mActivity;
@Mock
private Preference mPreference;
@Mock
private PreferenceScreen mScreen;
@Mock
private UserManager mUserManager;
private Context mContext;
private LocationModePreferenceController mController;
private LifecycleOwner mLifecycleOwner;
private Lifecycle mLifecycle;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
mController = new LocationModePreferenceController(mContext, mFragment, mLifecycle);
when(mFragment.getActivity()).thenReturn(mActivity);
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
}
@Test
@Config(qualifiers = "mcc999")
public void locationModePreference_ifXmlSetToFalse_shouldNotBeAvailable() {
assertFalse(mController.isAvailable());
}
@Test
public void locationModePreference_ifXmlSetToTrue_shouldBeAvailable() {
assertTrue(mController.isAvailable());
}
@Test
public void onLocationModeChanged_locationOff_shouldDisablePreference() {
when(mUserManager.hasUserRestriction(any())).thenReturn(false);
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_OFF, false);
verify(mPreference).setEnabled(false);
}
@Test
public void onLocationModeChanged_restricted_shouldDisablePreference() {
when(mUserManager.hasUserRestriction(any())).thenReturn(true);
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_BATTERY_SAVING, false);
verify(mPreference).setEnabled(false);
}
@Test
public void onLocationModeChanged_locationOnNotRestricted_shouldEnablePreference() {
when(mUserManager.hasUserRestriction(any())).thenReturn(false);
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_BATTERY_SAVING, false);
verify(mPreference).setEnabled(true);
}
@Test
public void onLocationModeChanged_shouldUpdateSummary() {
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_BATTERY_SAVING, false);
verify(mPreference).setSummary(anyInt());
}
@Test
public void handlePreferenceTreeClick_shouldStartLocationModeFragment() {
final Preference preference = new Preference(mContext);
preference.setKey(mController.getPreferenceKey());
mController.handlePreferenceTreeClick(preference);
verify(mActivity).startPreferencePanel(any(), eq(LocationMode.class.getName()), any(),
eq(R.string.location_mode_screen_title), any(), any(), anyInt());
}
}

140
tests/robotests/src/com/android/settings/location/LocationModeRadioButtonPreferenceControllerTest.java
View File

@@ -1,140 +0,0 @@
/*
* Copyright (C) 2017 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.location;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.arch.lifecycle.LifecycleOwner;
import android.content.Context;
import android.provider.Settings;
import android.support.v7.preference.PreferenceScreen;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowSecureSettings;
import com.android.settings.widget.RadioButtonPreference;
import com.android.settingslib.core.lifecycle.Lifecycle;
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;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(
manifest = TestConfig.MANIFEST_PATH,
sdk = TestConfig.SDK_VERSION,
shadows = {ShadowSecureSettings.class})
public class LocationModeRadioButtonPreferenceControllerTest {
@Mock
private RadioButtonPreference mPreference;
@Mock
private PreferenceScreen mScreen;
private Context mContext;
private LocationModeRadioButtonPreferenceController mController;
private LifecycleOwner mLifecycleOwner;
private Lifecycle mLifecycle;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
mController = new LocationModeRadioButtonPreferenceControllerTestable(mContext, mLifecycle);
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
}
@Test
public void displayPreference_shouldAddClickListener() {
mController.displayPreference(mScreen);
verify(mPreference).setOnClickListener(mController);
}
@Test
public void onRadioButtonClicked_shouldSetLocationModeToOwnMode() {
mController.displayPreference(mScreen);
Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF);
mController.onRadioButtonClicked(mPreference);
assertThat(Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF))
.isEqualTo(mController.getLocationMode());
}
@Test
public void onLocationModeChanged_otherModeSelected_shouldUncheckPreference() {
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_BATTERY_SAVING, false);
verify(mPreference).setChecked(false);
}
@Test
public void onLocationModeChanged_ownModeSelected_shouldCheckPreference() {
mController.displayPreference(mScreen);
mController.onLocationModeChanged(mController.getLocationMode(), false);
verify(mPreference).setChecked(true);
}
@Test
public void onLocationModeChanged_locationOff_shouldDisablePreference() {
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_OFF, false);
verify(mPreference).setEnabled(false);
}
@Test
public void onLocationModeChanged_locationOn_shouldDisablePreference() {
mController.displayPreference(mScreen);
mController.onLocationModeChanged(Settings.Secure.LOCATION_MODE_BATTERY_SAVING, false);
verify(mPreference).setEnabled(true);
}
private class LocationModeRadioButtonPreferenceControllerTestable
extends LocationModeRadioButtonPreferenceController {
public LocationModeRadioButtonPreferenceControllerTestable(Context context,
Lifecycle lifecycle) {
super(context, lifecycle);
}
@Override
public String getPreferenceKey() {
return "test";
}
@Override
protected int getLocationMode() {
return Settings.Secure.LOCATION_MODE_HIGH_ACCURACY;
}
}
}

57
tests/robotests/src/com/android/settings/location/LocationModeSensorsOnlyPreferenceControllerTest.java
View File

@@ -1,57 +0,0 @@
/*
* Copyright (C) 2017 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.location;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import android.arch.lifecycle.LifecycleOwner;
import android.content.Context;
import android.provider.Settings;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class LocationModeSensorsOnlyPreferenceControllerTest {
private LifecycleOwner mLifecycleOwner;
private Lifecycle mLifecycle;
@Before
public void setUp() {
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
}
@Test
public void getLocationMode_shouldReturnModeSensorsOnly() {
final LocationModeSensorsOnlyPreferenceController controller =
new LocationModeSensorsOnlyPreferenceController(mock(Context.class), mLifecycle);
assertThat(controller.getLocationMode())
.isEqualTo(Settings.Secure.LOCATION_MODE_SENSORS_ONLY);
}
}

73
tests/robotests/src/com/android/settings/location/LocationModeTest.java
View File

@@ -1,73 +0,0 @@
/*
* Copyright (C) 2017 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.location;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
import android.content.Context;
import android.provider.SearchIndexableResource;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.XmlTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class LocationModeTest {
private Context mContext;
private LocationMode mFragment;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
mFragment = new LocationMode();
}
@Test
public void testSearchIndexProvider_shouldIndexResource() {
final List<SearchIndexableResource> indexRes =
mFragment.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex(mContext,
true /* enabled */);
assertThat(indexRes).isNotNull();
assertThat(indexRes.get(0).xmlResId).isEqualTo(mFragment.getPreferenceScreenResId());
}
@Test
@Config(qualifiers = "mcc999")
public void testSearchIndexProvider_ifPageDisabled_shouldNotIndexResource() {
final List<String> niks = LocationMode.SEARCH_INDEX_DATA_PROVIDER
.getNonIndexableKeys(mContext);
final int xmlId = mFragment.getPreferenceScreenResId();
final List<String> keys = XmlTestUtils.getKeysFromPreferenceXml(mContext, xmlId);
assertThat(niks).containsAllIn(keys);
}
}

27
tests/robotests/src/com/android/settings/location/LocationPreferenceControllerTest.java
View File

@@ -109,45 +109,30 @@ public class LocationPreferenceControllerTest {
}
@Test
public void getLocationSummary_sensorsOnly_shouldSetSummarySensorsOnly() {
public void getLocationSummary_sensorsOnly_shouldSetSummaryOn() {
Secure.putInt(mContext.getContentResolver(),
Secure.LOCATION_MODE, Secure.LOCATION_MODE_SENSORS_ONLY);
assertThat(mController.getLocationSummary(mContext)).isEqualTo(
mContext.getString(R.string.location_on_summary,
mContext.getString(R.string.location_mode_sensors_only_title)));
mContext.getString(R.string.location_on_summary));
}
@Test
public void getLocationSummary_highAccuracy_shouldSetSummarHighAccuracy() {
public void getLocationSummary_highAccuracy_shouldSetSummaryOn() {
Secure.putInt(mContext.getContentResolver(),
Secure.LOCATION_MODE, Secure.LOCATION_MODE_HIGH_ACCURACY);
assertThat(mController.getLocationSummary(mContext)).isEqualTo(
mContext.getString(R.string.location_on_summary,
mContext.getString(R.string.location_mode_high_accuracy_title)));
mContext.getString(R.string.location_on_summary));
}
@Test
public void getLocationSummary_batterySaving_shouldSetSummaryBatterySaving() {
public void getLocationSummary_batterySaving_shouldSetSummaryOn() {
Secure.putInt(mContext.getContentResolver(),
Secure.LOCATION_MODE, Secure.LOCATION_MODE_BATTERY_SAVING);
assertThat(mController.getLocationSummary(mContext)).isEqualTo(
mContext.getString(R.string.location_on_summary,
mContext.getString(R.string.location_mode_battery_saving_title)));
}
@Test
public void getLocationString_shouldCorrectString() {
assertThat(mController.getLocationString(Secure.LOCATION_MODE_OFF)).isEqualTo(
R.string.location_mode_location_off_title);
assertThat(mController.getLocationString(Secure.LOCATION_MODE_SENSORS_ONLY)).isEqualTo(
R.string.location_mode_sensors_only_title);
assertThat(mController.getLocationString(Secure.LOCATION_MODE_BATTERY_SAVING)).isEqualTo(
R.string.location_mode_battery_saving_title);
assertThat(mController.getLocationString(Secure.LOCATION_MODE_HIGH_ACCURACY)).isEqualTo(
R.string.location_mode_high_accuracy_title);
mContext.getString(R.string.location_on_summary));
}
@Test