@Override
public boolean isAvailable() {
return Settings.Global.getInt(mContext.getContentResolver(),
- android.provider.Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED, 1)
- == 1;
+ Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED, 1) == 1;
}
}
public CarrierPreferenceController(Context context, String key) {
super(context, key);
+ mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
mCarrierConfigManager = new CarrierConfigManager(context);
mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
}
public MobileDataPreferenceController(Context context, String key) {
super(context, key);
+ mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
mSubscriptionManager = context.getSystemService(SubscriptionManager.class);
mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper()));
mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
* Returns true if Wifi calling is enabled for at least one phone.
*/
public static boolean isWifiCallingEnabled(Context context) {
- int phoneCount = TelephonyManager.from(context).getPhoneCount();
+ int phoneCount = context.getSystemService(TelephonyManager.class).getPhoneCount();
for (int i = 0; i < phoneCount; i++) {
if (isWifiCallingEnabled(context, i)) {
return true;
*/
public static void setMobileDataEnabled(Context context, int subId, boolean enabled,
boolean disableOtherSubscriptions) {
- final TelephonyManager telephonyManager = TelephonyManager.from(context)
+ final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
.createForSubscriptionId(subId);
final SubscriptionManager subscriptionManager = context.getSystemService(
SubscriptionManager.class);
if (subInfoList != null) {
for (SubscriptionInfo subInfo : subInfoList) {
if (subInfo.getSubscriptionId() != subId) {
- TelephonyManager.from(context).createForSubscriptionId(
+ context.getSystemService(TelephonyManager.class).createForSubscriptionId(
subInfo.getSubscriptionId()).setDataEnabled(false);
}
}
if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
return false;
}
- final TelephonyManager telephonyManager = TelephonyManager.from(context)
+ final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
.createForSubscriptionId(subId);
final PersistableBundle carrierConfig = context.getSystemService(
CarrierConfigManager.class).getConfigForSubId(subId);
}
private static boolean isGsmBasicOptions(Context context, int subId) {
- final TelephonyManager telephonyManager = TelephonyManager.from(context)
+ final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
.createForSubscriptionId(subId);
final PersistableBundle carrierConfig = context.getSystemService(
CarrierConfigManager.class).getConfigForSubId(subId);
* settings
*/
public static boolean isWorldMode(Context context, int subId) {
- final TelephonyManager telephonyManager = TelephonyManager.from(context)
+ final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
.createForSubscriptionId(subId);
boolean worldModeOn = false;
final String configString = context.getString(R.string.config_world_mode);
Context con = context.createPackageContext("com.android.systemui", 0);
int id = con.getResources().getIdentifier("config_show4GForLTE",
"bool", "com.android.systemui");
- return con.getResources().getBoolean(id);
+ return con.getResources().getBoolean(id);
} catch (PackageManager.NameNotFoundException e) {
Log.e(TAG, "NameNotFoundException for show4GFotLTE");
return false;
*/
public static boolean isTdscdmaSupported(Context context, int subId) {
return isTdscdmaSupported(context,
- TelephonyManager.from(context).createForSubscriptionId(subId));
+ context.getSystemService(TelephonyManager.class).createForSubscriptionId(subId));
}
//TODO(b/117651939): move it to telephony
public RoamingPreferenceController(Context context, String key) {
super(context, key);
+ mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class);
mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper()));
mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
+import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import androidx.preference.Preference;
public CdmaBasePreferenceController(Context context, String key) {
super(context, key);
+ mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper()));
}
import android.util.Log;
import androidx.preference.Preference;
-import androidx.preference.PreferenceGroup;
import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.core.AbstractPreferenceController;
return true;
}
- // finds the preference recursively and removes it from its parent
- private void findAndRemovePreference(PreferenceGroup prefGroup, String key) {
- final int preferenceCount = prefGroup.getPreferenceCount();
- for (int i = preferenceCount - 1; i >= 0; i--) {
- final Preference preference = prefGroup.getPreference(i);
- final String curKey = preference.getKey();
-
- if (curKey != null && curKey.equals(key)) {
- mPreference = preference;
- prefGroup.removePreference(preference);
- }
-
- if (preference instanceof PreferenceGroup) {
- findAndRemovePreference((PreferenceGroup) preference, key);
- }
- }
- }
-
protected void onResume(NotificationBackend.AppRow appRow,
@Nullable NotificationChannel channel, @Nullable NotificationChannelGroup group,
RestrictedLockUtils.EnforcedAdmin admin) {
SliceBuilderUtils.getPreferenceController(mContext, xmlSlice);
// Only add pre-approved Slices available on the device.
- if (controller.isAvailable() && controller.isSliceable()) {
+ if (controller.isSliceable() && controller.isAvailable()) {
xmlSliceData.add(xmlSlice);
}
}
return;
}
- SQLiteDatabase database = mHelper.getWritableDatabase();
+ final SQLiteDatabase database = mHelper.getWritableDatabase();
+ long startTime = System.currentTimeMillis();
+ database.beginTransaction();
try {
- long startTime = System.currentTimeMillis();
- database.beginTransaction();
-
mHelper.reconstruct(mHelper.getWritableDatabase());
List<SliceData> indexData = getSliceData();
insertSliceData(database, indexData);
} finally {
database.endTransaction();
}
+ database.close();
}
@VisibleForTesting
@Override
public boolean isAvailable() {
- return true;
+ return true;
}
@Override
final SwitchPreference enableWifiWakeup = (SwitchPreference) preference;
enableWifiWakeup.setChecked(getWifiWakeupEnabled()
- && getWifiScanningEnabled()
- && mLocationManager.isLocationEnabled());
+ && getWifiScanningEnabled()
+ && mLocationManager.isLocationEnabled());
if (!mLocationManager.isLocationEnabled()) {
preference.setSummary(getNoLocationSummary());
} else {
}
}
- @VisibleForTesting CharSequence getNoLocationSummary() {
+ @VisibleForTesting
+ CharSequence getNoLocationSummary() {
AnnotationSpan.LinkInfo linkInfo = new AnnotationSpan.LinkInfo("link", null);
CharSequence locationText = mContext.getText(R.string.wifi_wakeup_summary_no_location);
return AnnotationSpan.linkify(locationText, linkInfo);
import static org.mockito.Mockito.when;
import static org.robolectric.RuntimeEnvironment.application;
+import android.app.Activity;
import android.app.KeyguardManager;
import android.content.Intent;
import android.os.Bundle;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowKeyguardManager;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(
shadows = {
- ShadowUserManager.class,
- ShadowKeyguardManager.class,
+ ShadowUserManager.class,
+ ShadowKeyguardManager.class,
})
public class RestrictedListPreferenceTest {
private static final int PROFILE_USER_ID = 11;
private static final int UNLAUNCHABLE_REASON_QUIET_MODE = 1;
private static final String EXTRA_UNLAUNCHABLE_REASON = "unlaunchable_reason";
+ private Activity mActivity;
private ShadowUserManager mShadowUserManager;
private ShadowKeyguardManager mShadowKeyguardManager;
private RestrictedListPreference mPreference;
@Before
public void setUp() {
+ mActivity = Robolectric.setupActivity(Activity.class);
mShadowKeyguardManager =
Shadows.shadowOf(application.getSystemService(KeyguardManager.class));
mMockHelper = mock(RestrictedPreferenceHelper.class);
mShadowUserManager = ShadowUserManager.getShadow();
- mPreference = new RestrictedListPreference(application, mock(AttributeSet.class));
+ mPreference = new RestrictedListPreference(mActivity, mock(AttributeSet.class));
mPreference.setProfileUserId(PROFILE_USER_ID);
ReflectionHelpers.setField(mPreference, "mHelper", mMockHelper);
}
// Make sure that the performClick method on the helper is never reached.
verify(mMockHelper, never()).performClick();
// Assert that a CONFIRM_DEVICE_CREDENTIAL intent has been started.
- Intent started = Shadows.shadowOf(application).getNextStartedActivity();
+ Intent started = Shadows.shadowOf(mActivity).getNextStartedActivity();
assertThat(started.getExtras().getInt(Intent.EXTRA_USER_ID)).isEqualTo(PROFILE_USER_ID);
assertThat(started.getAction())
.isEqualTo(KeyguardManager.ACTION_CONFIRM_DEVICE_CREDENTIAL_WITH_USER);
// Make sure that the performClick method on the helper is never reached.
verify(mMockHelper, never()).performClick();
// Assert that a new intent for enabling the work profile is started.
- Intent started = Shadows.shadowOf(application).getNextStartedActivity();
+ Intent started = Shadows.shadowOf(mActivity).getNextStartedActivity();
Bundle extras = started.getExtras();
int reason = extras.getInt(EXTRA_UNLAUNCHABLE_REASON);
assertThat(reason).isEqualTo(UNLAUNCHABLE_REASON_QUIET_MODE);
package com.android.settings;
-import static com.android.settings.testutils.ResIdSubject.assertResId;
-
import static com.google.common.truth.Truth.assertThat;
import android.content.Intent;
public class SetupWizardUtilsTest {
@Test
- public void testCopySetupExtras() throws Throwable {
+ public void testCopySetupExtras() {
Intent fromIntent = new Intent();
final String theme = "TEST_THEME";
fromIntent.putExtra(WizardManagerHelper.EXTRA_THEME, theme);
Intent intent = new Intent();
intent.putExtra(WizardManagerHelper.EXTRA_THEME, WizardManagerHelper.THEME_GLIF_V2);
- assertResId(SetupWizardUtils.getTheme(intent)).isEqualTo(R.style.GlifV2Theme);
+ assertThat(SetupWizardUtils.getTheme(intent)).isEqualTo(R.style.GlifV2Theme);
}
@Test
WizardManagerHelper.THEME_GLIF_V2_LIGHT);
Intent intent = new Intent();
- assertResId(SetupWizardUtils.getTheme(intent)).isEqualTo(R.style.GlifV2Theme_Light);
+ assertThat(SetupWizardUtils.getTheme(intent)).isEqualTo(R.style.GlifV2Theme_Light);
}
@Test
WizardManagerHelper.THEME_GLIF_V3_LIGHT);
Intent intent = new Intent();
- assertResId(SetupWizardUtils.getTheme(intent)).isEqualTo(R.style.GlifV3Theme_Light);
- assertResId(SetupWizardUtils.getTransparentTheme(intent))
+ assertThat(SetupWizardUtils.getTheme(intent)).isEqualTo(R.style.GlifV3Theme_Light);
+ assertThat(SetupWizardUtils.getTransparentTheme(intent))
.isEqualTo(R.style.GlifV3Theme_Light_Transparent);
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothHearingAid;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
-import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
import org.robolectric.shadow.api.Shadow;
private ShadowBluetoothAdapter mShadowBluetoothAdapter;
private BluetoothManager mBluetoothManager;
private BluetoothDevice mBluetoothDevice;
- private Context mContext;
+ private Activity mContext;
private Preference mHearingAidPreference;
private AccessibilityHearingAidPreferenceController mPreferenceController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
setupBluetoothEnvironment();
setupHearingAidEnvironment();
mHearingAidPreference = new Preference(mContext);
}
@Test
- public void handleHearingAidPreferenceClick_withHearingAid_launchBluetoothDeviceDetailSetting()
- {
+ public void handleHearingAidPreferenceClick_withHearingAid_launchBluetoothDeviceDetailSetting
+ () {
mPreferenceController = spy(new AccessibilityHearingAidPreferenceController(mContext,
HEARING_AID_PREFERENCE));
mPreferenceController.setPreference(mHearingAidPreference);
public void onNotSupportHearingAidProfile_doNotDoReceiverOperation() {
//clear bluetooth supported profile
mShadowBluetoothAdapter.clearSupportedProfiles();
- mPreferenceController = new AccessibilityHearingAidPreferenceController(mContext, HEARING_AID_PREFERENCE);
+ mPreferenceController = new AccessibilityHearingAidPreferenceController(mContext,
+ HEARING_AID_PREFERENCE);
mPreferenceController.setPreference(mHearingAidPreference);
//not call registerReceiver()
mPreferenceController.onResume();
@Test
public void isChecked_enabled() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, ON);
mController.updateState(mPreference);
@Test
public void isChecked_disabled() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, OFF);
mController.updateState(mPreference);
@Test
public void updateState_shouldRefreshSummary() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, ON);
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
.isEqualTo(mContext.getString(R.string.accessibility_feature_state_on));
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, OFF);
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
@Test
public void isChecked_enabled() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, ON);
assertThat(mController.isChecked()).isTrue();
@Test
public void isChecked_disabled() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, OFF);
assertThat(mController.isChecked()).isFalse();
@Test
public void updateState_shouldRefreshSummary() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, ON);
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
.isEqualTo(mContext.getText(R.string.accessibility_feature_state_on));
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, OFF);
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
@Test
public void isChecked_enabled() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, ON);
assertThat(mController.isChecked()).isTrue();
@Test
public void isChecked_disabled() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, OFF);
assertThat(mController.isChecked()).isFalse();
}
@Implementation
- static boolean isApplicable(Resources res) {
+ protected static boolean isApplicable(Resources res) {
return sIsApplicable;
}
import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AuthenticatorDescription;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.SyncAdapterType;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
@Mock(answer = RETURNS_DEEP_STUBS)
private AccountManager mAccountManager;
- private Context mContext;
+ private Activity mActivity;
private AccountSyncPreferenceController mController;
private Preference mPreference;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = RuntimeEnvironment.application;
+ mActivity = Robolectric.setupActivity(Activity.class);
ShadowApplication.getInstance().setSystemService(Context.ACCOUNT_SERVICE, mAccountManager);
when(mAccountManager.getAuthenticatorTypesAsUser(anyInt())).thenReturn(
new AuthenticatorDescription[0]);
when(mAccountManager.getAccountsAsUser(anyInt())).thenReturn(new Account[0]);
- mPreference = new Preference(mContext);
+ mPreference = new Preference(mActivity);
mPreference.setKey("account_sync");
- mController = new AccountSyncPreferenceController(mContext);
+ mController = new AccountSyncPreferenceController(mActivity);
mController.init(new Account("acct1", "type1"), new UserHandle(3));
}
mController.updateSummary(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.account_sync_summary_all_off));
+ .isEqualTo(mActivity.getString(R.string.account_sync_summary_all_off));
}
@Test
mController.updateSummary(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.account_sync_summary_all_off));
+ .isEqualTo(mActivity.getString(R.string.account_sync_summary_all_off));
}
@Test
mController.updateSummary(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.account_sync_summary_all_off));
+ .isEqualTo(mActivity.getString(R.string.account_sync_summary_all_off));
}
@Test
mController.updateSummary(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.account_sync_summary_all_off));
+ .isEqualTo(mActivity.getString(R.string.account_sync_summary_all_off));
}
@Test
mController.updateSummary(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.account_sync_summary_all_on));
+ .isEqualTo(mActivity.getString(R.string.account_sync_summary_all_on));
}
@Test
mController.updateSummary(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.account_sync_summary_some_on, 3, 4));
+ .isEqualTo(mActivity.getString(R.string.account_sync_summary_some_on, 3, 4));
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ResolveInfo;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
public void setUp() {
MockitoAnnotations.initMocks(this);
mController = new EmergencyInfoPreferenceController(mContext);
- mPreference = new Preference(RuntimeEnvironment.application);
+ mPreference = new Preference(Robolectric.setupActivity(Activity.class));
mPreference.setKey(mController.getPreferenceKey());
when(mScreen.findPreference(mPreference.getKey())).thenReturn(mPreference);
}
mController.updateState(preference);
verify(preference).setSummary(
- mContext.getString(R.string.emergency_info_summary, "user 1"));
+ mContext.getString(R.string.emergency_info_summary, "user 1"));
}
@Test
public void handlePreferenceTreeClick_shouldStartActivity() {
final ShadowApplication application = ShadowApplication.getInstance();
- final Context context = RuntimeEnvironment.application;
- final Preference preference = new Preference(context);
+ final Activity activity = Robolectric.setupActivity(Activity.class);
+ final Preference preference = new Preference(activity);
preference.setKey("emergency_info");
- mController = new EmergencyInfoPreferenceController(context);
+ mController = new EmergencyInfoPreferenceController(activity);
mController.handlePreferenceTreeClick(preference);
import android.content.Context;
import android.content.Intent;
-import android.os.UserManager;
import android.provider.Settings;
import androidx.preference.Preference;
import com.android.settings.applications.ProcessStatsDetail;
import com.android.settings.core.BasePreferenceController;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowUserManager;
+import org.junit.After;
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.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = {ShadowUserManager.class})
public class AppMemoryPreferenceControllerTest {
@Mock
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- Shadows.shadowOf(userManager).setIsAdminUser(true);
+ ShadowUserManager.getShadow().setIsAdminUser(true);
mController =
spy(new AppMemoryPreferenceController(mContext, mFragment, null /* lifecycle */));
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
when(mFragment.getActivity()).thenReturn(mActivity);
}
+ @After
+ public void tearDown() {
+ ShadowUserManager.getShadow().reset();
+ }
+
@Test
@Config(qualifiers = "mcc999")
public void getAvailabilityStatus_developmentSettingsEnabled_shouldReturnAvailable() {
Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 1);
assertThat(mController.getAvailabilityStatus())
- .isEqualTo(BasePreferenceController.AVAILABLE);
+ .isEqualTo(BasePreferenceController.AVAILABLE);
}
@Test
Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 1);
assertThat(mController.getAvailabilityStatus())
- .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
+ .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0);
assertThat(mController.getAvailabilityStatus())
- .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
+ .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
import static com.google.common.truth.Truth.assertThat;
-import android.app.Application;
+import android.app.Activity;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.ResolveInfo;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowPackageManager;
@Mock
private AppInfoDashboardFragment mParent;
- private Application mApplication;
private ShadowPackageManager mPackageManager;
private AppSettingPreferenceController mController;
private Preference mPreference;
+ private Activity mActivity;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mApplication = RuntimeEnvironment.application;
- mPackageManager = Shadows.shadowOf(mApplication.getPackageManager());
- mController = new AppSettingPreferenceController(mApplication, "test_key");
+ mActivity = Robolectric.setupActivity(Activity.class);
+ mPackageManager = Shadows.shadowOf(RuntimeEnvironment.application.getPackageManager());
+ mController = new AppSettingPreferenceController(mActivity, "test_key");
mController.setPackageName(TEST_PKG_NAME).setParentFragment(mParent);
- mPreference = new Preference(mApplication);
+ mPreference = new Preference(mActivity);
mPreference.setKey(mController.getPreferenceKey());
}
mPackageManager.addResolveInfoForIntent(RESOLVED_INTENT, info);
assertThat(mController.handlePreferenceTreeClick(mPreference)).isTrue();
- assertThat(Shadows.shadowOf(mApplication).getNextStartedActivity().getComponent())
+ assertThat(Shadows.shadowOf(mActivity).getNextStartedActivity().getComponent())
.isEqualTo(TEST_INTENT.getComponent());
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
import android.os.UserManager;
import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class DefaultAppShortcutPreferenceControllerBaseTest {
@Mock
private AppInfoDashboardFragment mFragment;
@Mock
- private PreferenceScreen mScreen;
- @Mock
private Preference mPreference;
- private Context mContext;
+ private Activity mActivity;
private TestPreferenceController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
- when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
- mController = new TestPreferenceController(mContext, mFragment);
+ mActivity = spy(Robolectric.setupActivity(Activity.class));
+ when(mActivity.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
+ mController = new TestPreferenceController(mActivity, mFragment);
final String key = mController.getPreferenceKey();
when(mPreference.getKey()).thenReturn(key);
}
mController.isDefault = true;
mController.updateState(mPreference);
- String yesString = mContext.getString(R.string.yes);
+ String yesString = mActivity.getString(R.string.yes);
verify(mPreference).setSummary(yesString);
}
mController.updateState(mPreference);
- String noString = mContext.getString(R.string.no);
+ String noString = mActivity.getString(R.string.no);
verify(mPreference).setSummary(noString);
}
public void handlePreferenceTreeClick_shouldStartDefaultAppSettings() {
mController.handlePreferenceTreeClick(mPreference);
- verify(mContext).startActivity(argThat(intent -> intent != null
+ verify(mActivity).startActivity(argThat(intent -> intent != null
&& intent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT).equals(
DefaultAppSettings.class.getName())
&& intent.getBundleExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS)
package com.android.settings.applications.appinfo;
import static com.google.common.truth.Truth.assertThat;
+
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doAnswer;
import android.content.pm.PackageInfo;
import android.os.UserHandle;
import android.os.UserManager;
+
import com.android.settings.applications.AppStateInstallAppsBridge;
import com.android.settings.applications.AppStateInstallAppsBridge.InstallAppsState;
-import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settingslib.RestrictedPreferenceHelper;
import com.android.settingslib.RestrictedSwitchPreference;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
assertThat(fragment.refreshUi()).isTrue();
// Assertions
- assertThat(shadowUserManager.hasUserRestriction(
+ assertThat(userManager.hasUserRestriction(
UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES,
UserHandle.of(UserHandle.myUserId()))).isTrue();
assertThat(mSwitchPref.isDisabledByAdmin()).isTrue();
assertThat(fragment.refreshUi()).isTrue();
// Assertions
- assertThat(shadowUserManager.hasUserRestriction(
+ assertThat(userManager.hasUserRestriction(
UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY,
UserHandle.of(UserHandle.myUserId()))).isTrue();
assertThat(mSwitchPref.isDisabledByAdmin()).isTrue();
assertThat(fragment.refreshUi()).isTrue();
// Assertions
- assertThat(shadowUserManager.hasUserRestriction(
+ assertThat(userManager.hasUserRestriction(
UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY,
UserHandle.of(UserHandle.myUserId()))).isTrue();
- assertThat(shadowUserManager.hasUserRestriction(
+ assertThat(userManager.hasUserRestriction(
UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES,
UserHandle.of(UserHandle.myUserId()))).isTrue();
assertThat(mSwitchPref.isDisabledByAdmin()).isTrue();
mContext = spy(RuntimeEnvironment.application);
when(mContext.getPackageManager()).thenReturn(mPackageManager);
mContentResolver = mContext.getContentResolver();
- mEnableEphemeralFeature = Settings.Secure.getInt(mContentResolver,
+ mEnableEphemeralFeature = Settings.Global.getInt(mContentResolver,
ENABLE_EPHEMERAL_FEATURE, 1);
}
@After
public void tearDown() {
- Settings.Secure.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE,
+ Settings.Global.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE,
mEnableEphemeralFeature);
}
}
@Test
- public void testGetAvailabilityStatus_enableWebActiions() {
+ public void testGetAvailabilityStatus_enableWebActions() {
when(mPackageManager.getInstantAppResolverSettingsComponent()).thenReturn(mComponentName);
mController = new InstantAppAccountPreferenceController(mContext, PREF_KEY);
- Settings.Secure.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 1);
+ Settings.Global.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 1);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
public void testGetAvailabilityStatus_disableWebActions() {
when(mPackageManager.getInstantAppResolverSettingsComponent()).thenReturn(mComponentName);
mController = new InstantAppAccountPreferenceController(mContext, PREF_KEY);
- Settings.Secure.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 0);
+ Settings.Global.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 0);
assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
}
mContentResolver = mContext.getContentResolver();
mController = new InstantAppWebActionPreferenceController(mContext, PREF_KEY);
mSwitchPreference = new SwitchPreference(mContext);
- mEnableEphemeralFeature = Settings.Secure.getInt(mContentResolver,
+ mEnableEphemeralFeature = Settings.Global.getInt(mContentResolver,
ENABLE_EPHEMERAL_FEATURE, 1);
}
@After
public void tearDown() {
- Settings.Secure.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE,
+ Settings.Global.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE,
mEnableEphemeralFeature);
}
@Test
public void testGetAvailabilityStatus_enableWebActions() {
- Settings.Secure.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 1);
+ Settings.Global.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 1);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void testGetAvailabilityStatus_disableWebActions() {
- Settings.Secure.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 0);
+ Settings.Global.putInt(mContentResolver, ENABLE_EPHEMERAL_FEATURE, 0);
assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
}
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.verify;
-import static org.robolectric.RuntimeEnvironment.application;
import android.content.Intent;
import android.hardware.fingerprint.FingerprintManager;
import android.hardware.fingerprint.FingerprintManager.EnrollmentCallback;
-import android.media.AudioAttributes;
import android.os.CancellationSignal;
-import android.os.VibrationEffect;
-import android.os.Vibrator;
import android.widget.TextView;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResourcesImpl;
import com.android.settings.testutils.shadow.ShadowUtils;
-import com.android.settings.testutils.shadow.ShadowVibrator;
+
import org.junit.After;
import org.junit.Before;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
-import org.robolectric.shadow.api.Shadow;
-
-import java.util.concurrent.TimeUnit;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {
SettingsShadowResourcesImpl.class,
- ShadowUtils.class,
- ShadowVibrator.class})
+ ShadowUtils.class})
public class FingerprintEnrollEnrollingTest {
@Mock
public void setUp() {
MockitoAnnotations.initMocks(this);
ShadowUtils.setFingerprintManager(mFingerprintManager);
- ShadowVibrator.addToServiceMap();
FakeFeatureFactory.setupForTest();
mActivity = Robolectric.buildActivity(
@After
public void tearDown() {
ShadowUtils.reset();
- ShadowVibrator.reset();
}
@Test
- public void fingerprintEnrollHelp_shouldShowHelpTextAndVibrate() {
+ public void fingerprintEnrollHelp_shouldShowHelpText() {
EnrollmentCallback enrollmentCallback = verifyAndCaptureEnrollmentCallback();
enrollmentCallback.onEnrollmentProgress(123);
TextView errorText = mActivity.findViewById(R.id.error_text);
assertThat(errorText.getText()).isEqualTo("test enrollment help");
-
- Robolectric.getForegroundThreadScheduler().advanceBy(2, TimeUnit.MILLISECONDS);
-
- ShadowVibrator shadowVibrator =
- Shadow.extract(application.getSystemService(Vibrator.class));
- verify(shadowVibrator.delegate).vibrate(
- anyInt(),
- nullable(String.class),
- any(VibrationEffect.class),
- nullable(String.class),
- nullable(AudioAttributes.class));
}
private EnrollmentCallback verifyAndCaptureEnrollmentCallback() {
Shadows.shadowOf(application.getPackageManager())
.setSystemFeature(PackageManager.FEATURE_FINGERPRINT, true);
- ShadowFingerprintManager.addToServiceMap();
FakeFeatureFactory.setupForTest();
@After
public void tearDown() {
ShadowStorageManager.reset();
- ShadowFingerprintManager.reset();
}
@Test
import android.content.Intent;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
-import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.annotation.Config;
-import org.robolectric.shadow.api.Shadow;
@RunWith(SettingsRobolectricTestRunner.class)
-@Config(shadows = {ShadowBluetoothAdapter.class})
public class AlwaysDiscoverableTest {
@Mock
private AlwaysDiscoverable mAlwaysDiscoverable;
private BluetoothAdapter mBluetoothAdapter;
- private ShadowBluetoothAdapter mShadowBluetoothAdapter;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mAlwaysDiscoverable = new AlwaysDiscoverable(mContext);
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
- mShadowBluetoothAdapter = Shadow.extract(BluetoothAdapter.getDefaultAdapter());
}
@Test
@Test
public void startSetsModeAndRegistersReceiver() {
- mShadowBluetoothAdapter.setScanMode(BluetoothAdapter.SCAN_MODE_NONE);
+ mBluetoothAdapter.setScanMode(BluetoothAdapter.SCAN_MODE_NONE);
mAlwaysDiscoverable.start();
assertThat(mBluetoothAdapter.getScanMode())
.isEqualTo(BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE);
}
private void sendScanModeChangedIntent(int newMode, int previousMode) {
- mShadowBluetoothAdapter.setScanMode(newMode);
+ mBluetoothAdapter.setScanMode(newMode);
Intent intent = new Intent(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
intent.putExtra(BluetoothAdapter.EXTRA_SCAN_MODE, newMode);
intent.putExtra(BluetoothAdapter.EXTRA_PREVIOUS_SCAN_MODE, previousMode);
import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
+import com.android.settingslib.testutils.DrawableTestHelper;
import org.junit.Before;
import org.junit.Test;
mPreference.onClicked();
verify(mMetricsFeatureProvider)
- .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_DISCONNECT);
+ .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_DISCONNECT);
}
@Test
mPreference.onClicked();
verify(mMetricsFeatureProvider)
- .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_CONNECT);
+ .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_CONNECT);
}
@Test
mPreference.onClicked();
verify(mMetricsFeatureProvider)
- .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR);
+ .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR);
verify(mMetricsFeatureProvider, never())
- .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR_DEVICES_WITHOUT_NAMES);
+ .action(mContext,
+ MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR_DEVICES_WITHOUT_NAMES);
}
@Test
mPreference.onClicked();
verify(mMetricsFeatureProvider)
- .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR);
+ .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR);
verify(mMetricsFeatureProvider)
- .action(mContext, MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR_DEVICES_WITHOUT_NAMES);
+ .action(mContext,
+ MetricsEvent.ACTION_SETTINGS_BLUETOOTH_PAIR_DEVICES_WITHOUT_NAMES);
}
@Test
@Test
public void imagingDeviceIcon_isICSettingsPrint() {
when(mCachedBluetoothDevice.getBatteryLevel())
- .thenReturn(BluetoothDevice.BATTERY_LEVEL_UNKNOWN);
+ .thenReturn(BluetoothDevice.BATTERY_LEVEL_UNKNOWN);
when(mCachedBluetoothDevice.getBtClass())
- .thenReturn(new BluetoothClass(BluetoothClass.Device.Major.IMAGING));
+ .thenReturn(new BluetoothClass(BluetoothClass.Device.Major.IMAGING));
mPreference.onDeviceAttributesChanged();
- assertThat(mPreference.getIcon()).isEqualTo(
- mContext.getDrawable(R.drawable.ic_settings_print));
+ DrawableTestHelper.assertDrawableResId(mPreference.getIcon(), R.drawable.ic_settings_print);
}
@Test
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.testutils.DrawableTestHelper;
import org.junit.Before;
import org.junit.Test;
Preference pref = mController.createBluetoothPairingPreference(ORDER);
assertThat(pref.getKey()).isEqualTo(BluetoothPairingPreferenceController.KEY_PAIRING);
- assertThat(pref.getIcon()).isEqualTo(mContext.getDrawable(R.drawable.ic_menu_add));
+ DrawableTestHelper.assertDrawableResId(pref.getIcon(), R.drawable.ic_menu_add);
assertThat(pref.getOrder()).isEqualTo(ORDER);
assertThat(pref.getTitle())
- .isEqualTo(mContext.getString(R.string.bluetooth_pairing_pref_title));
+ .isEqualTo(mContext.getString(R.string.bluetooth_pairing_pref_title));
}
@Test
import org.robolectric.RuntimeEnvironment;
import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
-import org.robolectric.shadow.api.Shadow;
import org.robolectric.shadows.ShadowApplication;
import java.util.ArrayList;
private DiscoverableFooterPreferenceController mDiscoverableFooterPreferenceController;
private BroadcastReceiver mBluetoothChangedReceiver;
private ShadowApplication mShadowApplication;
- private ShadowBluetoothAdapter mShadowBluetoothAdapter;
@Before
public void setUp() {
mAlwaysDiscoverable);
mBluetoothChangedReceiver = mDiscoverableFooterPreferenceController
.mBluetoothChangedReceiver;
- mShadowBluetoothAdapter = Shadow.extract(BluetoothAdapter.getDefaultAdapter());
}
@Test
@Test
public void onBluetoothStateChanged_bluetoothOn_updateTitle() {
- mShadowBluetoothAdapter.setName(DEVICE_NAME);
+ BluetoothAdapter.getDefaultAdapter().setName(DEVICE_NAME);
sendBluetoothStateChangedIntent(BluetoothAdapter.STATE_ON);
assertThat(mPreference.getTitle()).isEqualTo(generateTitle(DEVICE_NAME));
}
@Test
- public void onBluetoothStateChanged_bluetoothOff_updateTitle(){
- mShadowBluetoothAdapter.setName(DEVICE_NAME);
+ public void onBluetoothStateChanged_bluetoothOff_updateTitle() {
+ BluetoothAdapter.getDefaultAdapter().setName(DEVICE_NAME);
sendBluetoothStateChangedIntent(BluetoothAdapter.STATE_OFF);
assertThat(mPreference.getTitle()).isEqualTo(generateTitle(null));
import com.android.settings.connecteddevice.DevicePreferenceCallback;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.testutils.DrawableTestHelper;
import org.junit.Before;
import org.junit.Test;
mDeviceUpdater.initUsbPreference(mContext);
assertThat(mDeviceUpdater.mUsbPreference.getTitle()).isEqualTo("USB");
- assertThat(mDeviceUpdater.mUsbPreference.getIcon())
- .isEqualTo(mContext.getDrawable(R.drawable.ic_usb));
+ DrawableTestHelper.assertDrawableResId(
+ mDeviceUpdater.mUsbPreference.getIcon(), R.drawable.ic_usb);
assertThat(mDeviceUpdater.mUsbPreference.isSelectable()).isTrue();
}
package com.android.settings.connecteddevice.usb;
+import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
+import android.graphics.drawable.Drawable;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import com.android.settings.testutils.shadow.ShadowEntityHeaderController;
import com.android.settings.widget.EntityHeaderController;
import com.android.settingslib.core.lifecycle.Lifecycle;
+import com.android.settingslib.testutils.DrawableTestHelper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
+import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
mDetailsHeaderController.refresh(true, UsbManager.FUNCTION_NONE, UsbPort.POWER_ROLE_SINK,
UsbPort.DATA_ROLE_DEVICE);
verify(mHeaderController).setLabel(mContext.getString(R.string.usb_pref));
- verify(mHeaderController).setIcon(mContext.getDrawable(R.drawable.ic_usb));
+ verify(mHeaderController).setIcon(argThat((ArgumentMatcher<Drawable>) t -> {
+ DrawableTestHelper.assertDrawableResId(t, R.drawable.ic_usb);
+ return true;
+ }));
verify(mHeaderController).done(mActivity, true);
}
}
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
// Precondition: no metrics feature
assertThat(fragment.getMetricsFeatureProvider()).isNull();
- fragment.onAttach(ShadowApplication.getInstance().getApplicationContext());
+ fragment.onAttach(RuntimeEnvironment.application);
// Verify: has metrics feature
assertThat(fragment.getMetricsFeatureProvider()).isNotNull();
mCategoryByKeyMap.put(CATEGORY_HOMEPAGE, category);
// Sort their priorities
- mCategoryManager.sortCategories(ShadowApplication.getInstance().getApplicationContext(),
- mCategoryByKeyMap);
+ mCategoryManager.sortCategories(RuntimeEnvironment.application, mCategoryByKeyMap);
// Verify they are now sorted.
assertThat(category.getTile(0)).isSameAs(tile3);
import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowActivity;
-import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
import java.util.ArrayList;
ReflectionHelpers.setField(
mImpl, "mPackageManager", RuntimeEnvironment.application.getPackageManager());
FragmentActivity activity = Robolectric.buildActivity(FragmentActivity.class).get();
- final ShadowApplication application = ShadowApplication.getInstance();
- final Preference preference = new Preference(application.getApplicationContext());
+ final Preference preference = new Preference(RuntimeEnvironment.application);
final Tile tile = new Tile(mActivityInfo, CategoryKey.CATEGORY_HOMEPAGE);
mActivityInfo.metaData.putString(META_DATA_PREFERENCE_KEYHINT, "key");
mActivityInfo.metaData.putString("com.android.settings.intent.action", "TestAction");
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.ComponentName;
-import android.content.Context;
import android.content.Intent;
import android.graphics.Typeface;
import android.net.NetworkTemplate;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
-import org.robolectric.RuntimeEnvironment;
import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowActivity;
private static final long UPDATE_LAG_MILLIS = 10000000L;
private static final String DUMMY_CARRIER = "z-mobile";
- private Context mContext;
+ private Activity mActivity;
private PreferenceViewHolder mHolder;
private DataUsageSummaryPreference mSummaryPreference;
private TextView mUsageTitle;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
- mSummaryPreference = new DataUsageSummaryPreference(mContext, null /* attrs */);
- LayoutInflater inflater = LayoutInflater.from(mContext);
+ mActivity = spy(Robolectric.setupActivity(Activity.class));
+ mSummaryPreference = new DataUsageSummaryPreference(mActivity, null /* attrs */);
+ LayoutInflater inflater = LayoutInflater.from(mActivity);
View view = inflater.inflate(mSummaryPreference.getLayoutResource(), null /* root */,
false /* attachToRoot */);
bindViewHolder();
assertThat(mCarrierInfo.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mCarrierInfo.getCurrentTextColor()).isEqualTo(
- Utils.getColorAttrDefaultColor(mContext, android.R.attr.textColorSecondary));
+ Utils.getColorAttrDefaultColor(mActivity, android.R.attr.textColorSecondary));
assertThat(mCarrierInfo.getTypeface()).isEqualTo(Typeface.SANS_SERIF);
}
bindViewHolder();
assertThat(mCarrierInfo.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mCarrierInfo.getCurrentTextColor()).isEqualTo(
- Utils.getColorAttrDefaultColor(mContext, android.R.attr.colorError));
+ Utils.getColorAttrDefaultColor(mActivity, android.R.attr.colorError));
assertThat(mCarrierInfo.getTypeface()).isEqualTo(
DataUsageSummaryPreference.SANS_SERIF_MEDIUM);
}
bindViewHolder();
assertThat(mCycleTime.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mCycleTime.getText()).isEqualTo(
- mContext.getString(R.string.billing_cycle_less_than_one_day_left));
+ mActivity.getString(R.string.billing_cycle_less_than_one_day_left));
}
@Test
bindViewHolder();
assertThat(mCycleTime.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mCycleTime.getText()).isEqualTo(
- mContext.getString(R.string.billing_cycle_none_left));
+ mActivity.getString(R.string.billing_cycle_none_left));
}
@Test
assertThat(mDataUsed.getText().toString()).isEqualTo("1.00 MB used");
assertThat(mDataRemaining.getText().toString()).isEqualTo("9.00 MB left");
assertThat(mDataRemaining.getVisibility()).isEqualTo(View.VISIBLE);
- final int colorId = Utils.getColorAttrDefaultColor(mContext, android.R.attr.colorAccent);
+ final int colorId = Utils.getColorAttrDefaultColor(mActivity, android.R.attr.colorAccent);
assertThat(mDataRemaining.getCurrentTextColor()).isEqualTo(colorId);
}
bindViewHolder();
assertThat(mDataUsed.getText().toString()).isEqualTo("11.00 MB used");
assertThat(mDataRemaining.getText().toString()).isEqualTo("1.00 MB over");
- final int colorId = Utils.getColorAttrDefaultColor(mContext, android.R.attr.colorError);
+ final int colorId = Utils.getColorAttrDefaultColor(mActivity, android.R.attr.colorError);
assertThat(mDataRemaining.getCurrentTextColor()).isEqualTo(colorId);
}
bindViewHolder();
assertThat(mLaunchButton.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mLaunchButton.getText())
- .isEqualTo(mContext.getString(R.string.launch_mdp_app_text));
+ .isEqualTo(mActivity.getString(R.string.launch_mdp_app_text));
mLaunchButton.callOnClick();
ShadowActivity shadowActivity = Shadows.shadowOf(activity);
@Test
public void testSetUsageInfo_withOverflowStrings_dataRemainingNotShown() {
- LayoutInflater inflater = LayoutInflater.from(mContext);
+ LayoutInflater inflater = LayoutInflater.from(mActivity);
View view = inflater.inflate(mSummaryPreference.getLayoutResource(), null /* root */,
false /* attachToRoot */);
- TextView dataUsed = spy(new TextView(mContext));
- TextView dataRemaining = spy(new TextView(mContext));
+ TextView dataUsed = spy(new TextView(mActivity));
+ TextView dataRemaining = spy(new TextView(mActivity));
doReturn(dataUsed).when(mHolder).findViewById(R.id.data_usage_view);
doReturn(dataRemaining).when(mHolder).findViewById(R.id.data_remaining_view);
10 * BillingCycleSettings.MIB_IN_BYTES,
true /* hasMobileData */);
- when(mContext.getResources()).thenCallRealMethod();
- when(mContext.getText(R.string.data_used_formatted))
+ when(mActivity.getResources()).thenCallRealMethod();
+ when(mActivity.getText(R.string.data_used_formatted))
.thenReturn("^1 ^2 used with long trailing text");
- when(mContext.getText(R.string.data_remaining)).thenReturn("^1 left");
+ when(mActivity.getText(R.string.data_remaining)).thenReturn("^1 left");
bindViewHolder();
bindViewHolder();
assertThat(mUsageTitle.getText().toString())
- .isEqualTo(mContext.getString(R.string.data_usage_wifi_title));
+ .isEqualTo(mActivity.getString(R.string.data_usage_wifi_title));
assertThat(mUsageTitle.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mCycleTime.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mCycleTime.getText()).isEqualTo(cycleText);
assertThat(mDataLimits.getVisibility()).isEqualTo(View.GONE);
assertThat(mLaunchButton.getVisibility()).isEqualTo(View.VISIBLE);
assertThat(mLaunchButton.getText())
- .isEqualTo(mContext.getString(R.string.launch_wifi_text));
+ .isEqualTo(mActivity.getString(R.string.launch_wifi_text));
mLaunchButton.callOnClick();
ShadowActivity shadowActivity = Shadows.shadowOf(activity);
import com.android.settings.testutils.shadow.SettingsShadowResourcesImpl;
import com.android.settings.testutils.shadow.ShadowDashboardFragment;
import com.android.settings.testutils.shadow.ShadowDataUsageUtils;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.testutils.shadow.ShadowUtils;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
@Config(shadows = {
- SettingsShadowResourcesImpl.class,
- SettingsShadowResources.SettingsShadowTheme.class,
- ShadowUtils.class,
- ShadowDataUsageUtils.class,
- ShadowDashboardFragment.class
+ SettingsShadowResourcesImpl.class,
+ SettingsShadowResources.SettingsShadowTheme.class,
+ ShadowUtils.class,
+ ShadowDataUsageUtils.class,
+ ShadowDashboardFragment.class,
+ ShadowUserManager.class,
})
@RunWith(SettingsRobolectricTestRunner.class)
public class DataUsageSummaryTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowContext = ShadowApplication.getInstance();
+ ShadowUserManager.getShadow().setIsAdminUser(true);
shadowContext.setSystemService(Context.NETWORK_POLICY_SERVICE, mNetworkPolicyManager);
- mContext = shadowContext.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get());
mSummaryProvider = DataUsageSummary.SUMMARY_PROVIDER_FACTORY
.createSummaryProvider(mActivity, mSummaryLoader);
}
+ @After
+ public void tearDown() {
+ ShadowUserManager.getShadow().reset();
+ }
+
@Test
public void formatUsage_shouldLookLikeFormatFileSize() {
SettingsShadowResources.overrideResource(com.android.internal.R.string.fileSizeSuffix,
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
public void setUp() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowContext = ShadowApplication.getInstance();
- mContext = shadowContext.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
shadowContext.setSystemService(Context.CONNECTIVITY_SERVICE, mManager);
shadowContext.setSystemService(Context.TELEPHONY_SERVICE, mTelephonyManager);
shadowContext.setSystemService(Context.NETWORK_STATS_SERVICE, mNetworkStatsManager);
DataUsageUtils.hasEthernet(mContext);
verify(mNetworkStatsManager).querySummaryForUser(eq(ConnectivityManager.TYPE_ETHERNET),
- eq(subscriber), anyLong() /* startTime */, anyLong() /* endTime */);
+ eq(subscriber), anyLong() /* startTime */, anyLong() /* endTime */);
}
}
@Test
public void onDeveloperOptionsDisabled_shouldDisablePreference() {
mController.onDeveloperOptionsDisabled();
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.ADB_ENABLED, -1);
assertThat(mode).isEqualTo(AdbPreferenceController.ADB_SETTING_OFF);
@Test
public void onAdbDialogConfirmed_shouldEnableAdbSetting() {
mController.onAdbDialogConfirmed();
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.ADB_ENABLED, -1);
assertThat(mode).isEqualTo(AdbPreferenceController.ADB_SETTING_ON);
@Test
public void onAdbDialogDismissed_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(), Settings.Global.ADB_ENABLED,
+ Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.ADB_ENABLED,
AdbPreferenceController.ADB_SETTING_OFF);
mController.onAdbDialogDismissed();
import static org.mockito.Mockito.when;
import android.content.Context;
+import android.os.SystemProperties;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.shadows.ShadowSystemProperties;
@RunWith(SettingsRobolectricTestRunner.class)
public class BluetoothDeviceNoNamePreferenceControllerTest {
mContext = RuntimeEnvironment.application;
mController = new BluetoothDeviceNoNamePreferenceController(mContext);
when(mPreferenceScreen.findPreference(mController.getPreferenceKey()))
- .thenReturn(mPreference);
+ .thenReturn(mPreference);
mController.displayPreference(mPreferenceScreen);
}
public void onPreferenceChanged_settingEnabled_shouldTurnOnBluetoothDeviceNoName() {
mController.onPreferenceChange(mPreference, true /* new value */);
- final boolean mode = ShadowSystemProperties
- .native_get_boolean(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, false /* default */);
+ final boolean mode = SystemProperties.getBoolean(
+ BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY,
+ false /* default */);
assertThat(mode).isTrue();
}
public void onPreferenceChanged_settingDisabled_shouldTurnOffBluetoothDeviceNoName() {
mController.onPreferenceChange(mPreference, false /* new value */);
- final boolean mode = ShadowSystemProperties
- .native_get_boolean(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, true /* default */);
+ final boolean mode = SystemProperties.getBoolean(
+ BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, true /* default */);
assertThat(mode).isFalse();
}
@Test
public void updateState_settingEnabled_preferenceShouldBeChecked() {
- ShadowSystemProperties
- .native_set(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, Boolean.toString(true));
+ SystemProperties.set(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY,
+ Boolean.toString(true));
mController.updateState(mPreference);
verify(mPreference).setChecked(true);
@Test
public void updateState_settingDisabled_preferenceShouldNotBeChecked() {
- ShadowSystemProperties
- .native_set(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, Boolean.toString(false));
+ SystemProperties.set(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY,
+ Boolean.toString(false));
mController.updateState(mPreference);
verify(mPreference).setChecked(false);
public void onDeveloperOptionsDisabled_shouldDisablePreference() {
mController.onDeveloperOptionsDisabled();
- final boolean mode = ShadowSystemProperties
- .native_get_boolean(BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, true /* default */);
+ final boolean mode = SystemProperties.getBoolean(
+ BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY,
+ true /* default */);
assertThat(mode).isFalse();
verify(mPreference).setEnabled(false);
public void onPreferenceChanged_turnOnViewAttributes() {
mController.onPreferenceChange(null, true);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.DEBUG_VIEW_ATTRIBUTES, -1);
assertThat(mode).isEqualTo(DebugViewAttributesPreferenceController.SETTING_VALUE_ON);
public void onPreferenceChanged_turnOffViewAttributes() {
mController.onPreferenceChange(null, false);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.DEBUG_VIEW_ATTRIBUTES, -1);
assertThat(mode).isEqualTo(DebugViewAttributesPreferenceController.SETTING_VALUE_OFF);
@Test
public void updateState_preferenceShouldBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(), Settings.Global.DEBUG_VIEW_ATTRIBUTES,
+ Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.DEBUG_VIEW_ATTRIBUTES,
DebugViewAttributesPreferenceController.SETTING_VALUE_ON);
mController.updateState(mPreference);
@Test
public void updateState_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(), Settings.Global.DEBUG_VIEW_ATTRIBUTES,
+ Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.DEBUG_VIEW_ATTRIBUTES,
DebugViewAttributesPreferenceController.SETTING_VALUE_OFF);
mController.updateState(mPreference);
@Test
public void onDeveloperOptionsDisabled_shouldDisablePreference() {
mController.onDeveloperOptionsDisabled();
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.DEBUG_VIEW_ATTRIBUTES, -1);
assertThat(mode).isEqualTo(DebugViewAttributesPreferenceController.SETTING_VALUE_OFF);
import static org.mockito.Mockito.when;
import android.content.Context;
-import android.os.UserManager;
import android.provider.SearchIndexableResource;
import android.provider.Settings;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.widget.SwitchBar;
import com.android.settings.widget.ToggleSwitch;
import com.android.settingslib.development.AbstractEnableAdbPreferenceController;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
-import org.robolectric.shadows.ShadowUserManager;
import org.robolectric.util.ReflectionHelpers;
import java.util.List;
@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = ShadowUserManager.class)
public class DevelopmentSettingsDashboardFragmentTest {
private ToggleSwitch mSwitch;
mSwitch = switchBar.getSwitch();
mDashboard = spy(new DevelopmentSettingsDashboardFragment());
ReflectionHelpers.setField(mDashboard, "mSwitchBar", switchBar);
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- mShadowUserManager = Shadows.shadowOf(userManager);
+ mShadowUserManager = ShadowUserManager.getShadow();
mShadowUserManager.setIsAdminUser(true);
}
@After
public void tearDown() {
ShadowEnableDevelopmentSettingWarningDialog.reset();
+ mShadowUserManager.reset();
}
@Test
@Test
public void shouldLogAsFeatureFlagPage() {
assertThat(mDashboard.getMetricsCategory())
- .isEqualTo(MetricsProto.MetricsEvent.DEVELOPMENT);
+ .isEqualTo(MetricsProto.MetricsEvent.DEVELOPMENT);
}
@Test
public void onOemUnlockDialogConfirmed_shouldCallControllerOemConfirmed() {
final OemUnlockPreferenceController controller = mock(OemUnlockPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(OemUnlockPreferenceController.class);
+ .getDevelopmentOptionsController(OemUnlockPreferenceController.class);
mDashboard.onOemUnlockDialogConfirmed();
verify(controller).onOemUnlockConfirmed();
}
public void onOemUnlockDialogConfirmed_shouldCallControllerOemDismissed() {
final OemUnlockPreferenceController controller = mock(OemUnlockPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(OemUnlockPreferenceController.class);
+ .getDevelopmentOptionsController(OemUnlockPreferenceController.class);
mDashboard.onOemUnlockDialogDismissed();
verify(controller).onOemUnlockDismissed();
}
public void onAdbDialogConfirmed_shouldCallControllerDialogConfirmed() {
final AdbPreferenceController controller = mock(AdbPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(AdbPreferenceController.class);
+ .getDevelopmentOptionsController(AdbPreferenceController.class);
mDashboard.onEnableAdbDialogConfirmed();
verify(controller).onAdbDialogConfirmed();
public void onAdbDialogDismissed_shouldCallControllerOemDismissed() {
final AdbPreferenceController controller = mock(AdbPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(AdbPreferenceController.class);
+ .getDevelopmentOptionsController(AdbPreferenceController.class);
mDashboard.onEnableAdbDialogDismissed();
verify(controller).onAdbDialogDismissed();
@Test
public void onAdbClearKeysDialogConfirmed_shouldCallControllerDialogConfirmed() {
final ClearAdbKeysPreferenceController controller =
- mock(ClearAdbKeysPreferenceController.class);
+ mock(ClearAdbKeysPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(ClearAdbKeysPreferenceController.class);
+ .getDevelopmentOptionsController(ClearAdbKeysPreferenceController.class);
mDashboard.onAdbClearKeysDialogConfirmed();
verify(controller).onClearAdbKeysConfirmed();
@Test
public void onDisableLogPersistDialogConfirmed_shouldCallControllerDialogConfirmed() {
final LogPersistPreferenceController controller =
- mock(LogPersistPreferenceController.class);
+ mock(LogPersistPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(LogPersistPreferenceController.class);
+ .getDevelopmentOptionsController(LogPersistPreferenceController.class);
mDashboard.onDisableLogPersistDialogConfirmed();
verify(controller).onDisableLogPersistDialogConfirmed();
@Test
public void onDisableLogPersistDialogRejected_shouldCallControllerDialogRejected() {
final LogPersistPreferenceController controller =
- mock(LogPersistPreferenceController.class);
+ mock(LogPersistPreferenceController.class);
doReturn(controller).when(mDashboard)
- .getDevelopmentOptionsController(LogPersistPreferenceController.class);
+ .getDevelopmentOptionsController(LogPersistPreferenceController.class);
mDashboard.onDisableLogPersistDialogRejected();
verify(controller).onDisableLogPersistDialogRejected();
import static org.mockito.Mockito.when;
import android.content.Context;
-import android.os.UserManager;
import androidx.lifecycle.LifecycleOwner;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.testutils.shadow.ShadowUtils;
import com.android.settings.widget.SwitchBar;
import com.android.settings.widget.SwitchBar.OnSwitchChangeListener;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
import java.util.List;
@RunWith(SettingsRobolectricTestRunner.class)
-@Config(shadows = ShadowUtils.class)
+@Config(shadows = {ShadowUtils.class, ShadowUserManager.class})
public class DevelopmentSwitchBarControllerTest {
@Mock
public void setUp() {
MockitoAnnotations.initMocks(this);
final Context context = RuntimeEnvironment.application;
- UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
- Shadows.shadowOf(userManager).setIsAdminUser(true);
+ ShadowUserManager.getShadow().setIsAdminUser(true);
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
mSwitchBar = new SwitchBar(context);
@After
public void tearDown() {
ShadowUtils.reset();
+ ShadowUserManager.getShadow().reset();
}
@Test
public void onPreferenceChanged_turnOnAutomaticUpdates() {
mController.onPreferenceChange(null, true);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.OTA_DISABLE_AUTOMATIC_UPDATE, -1);
assertThat(mode).isEqualTo(
public void onPreferenceChanged_turnOffAutomaticUpdates() {
mController.onPreferenceChange(null, false);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.OTA_DISABLE_AUTOMATIC_UPDATE, -1);
assertThat(mode).isEqualTo(
@Test
public void updateState_preferenceShouldBeChecked() {
- Settings.System
+ Settings.Global
.putInt(mContext.getContentResolver(), Settings.Global.OTA_DISABLE_AUTOMATIC_UPDATE,
DisableAutomaticUpdatesPreferenceController.ENABLE_UPDATES_SETTING);
mController.updateState(mPreference);
@Test
public void updateState_preferenceShouldNotBeChecked() {
- Settings.System
+ Settings.Global
.putInt(mContext.getContentResolver(), Settings.Global.OTA_DISABLE_AUTOMATIC_UPDATE,
DisableAutomaticUpdatesPreferenceController.DISABLE_UPDATES_SETTING);
mController.updateState(mPreference);
@Test
public void updateState_settingEnabled_preferenceShouldBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.ALWAYS_FINISH_ACTIVITIES, SETTING_VALUE_ON);
mController.updateState(mPreference);
@Test
public void updateState_settingDisabled_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.ALWAYS_FINISH_ACTIVITIES, SETTING_VALUE_OFF);
mController.updateState(mPreference);
public void onPreferenceChanged_turnOnPreference_shouldEnableMobileDataAlwaysOn() {
mController.onPreferenceChange(mPreference, true /* new value */);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.MOBILE_DATA_ALWAYS_ON, -1 /* default */);
assertThat(mode).isEqualTo(MobileDataAlwaysOnPreferenceController.SETTING_VALUE_ON);
public void onPreferenceChanged_turnOffPreference_shouldDisableMobileDataAlwaysOn() {
mController.onPreferenceChange(mPreference, false /* new value */);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.MOBILE_DATA_ALWAYS_ON, -1 /* default */);
assertThat(mode).isEqualTo(MobileDataAlwaysOnPreferenceController.SETTING_VALUE_OFF);
@Test
public void updateState_settingEnabled_preferenceShouldBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(), Settings.Global.MOBILE_DATA_ALWAYS_ON,
+ Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.MOBILE_DATA_ALWAYS_ON,
MobileDataAlwaysOnPreferenceController.SETTING_VALUE_ON);
mController.updateState(mPreference);
@Test
public void updateState_settingDisabled_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(), Settings.Global.MOBILE_DATA_ALWAYS_ON,
+ Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.MOBILE_DATA_ALWAYS_ON,
MobileDataAlwaysOnPreferenceController.SETTING_VALUE_OFF);
mController.updateState(mPreference);
@Test
public void onDeveloperOptionsSwitchDisabled_preferenceShouldBeDisabled() {
mController.onDeveloperOptionsSwitchDisabled();
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.MOBILE_DATA_ALWAYS_ON, -1 /* default */);
assertThat(mode).isEqualTo(MobileDataAlwaysOnPreferenceController.SETTING_VALUE_OFF);
public void onPreferenceChanged_turnOnStayAwake() {
mController.onPreferenceChange(null, true);
- final int mode = Settings.System.getInt(mContentResolver,
+ final int mode = Settings.Global.getInt(mContentResolver,
Settings.Global.STAY_ON_WHILE_PLUGGED_IN, -1);
assertThat(mode).isEqualTo(StayAwakePreferenceController.SETTING_VALUE_ON);
public void onPreferenceChanged_turnOffStayAwake() {
mController.onPreferenceChange(null, false);
- final int mode = Settings.System.getInt(mContentResolver,
+ final int mode = Settings.Global.getInt(mContentResolver,
Settings.Global.STAY_ON_WHILE_PLUGGED_IN, -1);
assertThat(mode).isEqualTo(StayAwakePreferenceController.SETTING_VALUE_OFF);
@Test
public void updateState_preferenceShouldBeChecked() {
- Settings.System.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
+ Settings.Global.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
StayAwakePreferenceController.SETTING_VALUE_ON);
mController.updateState(mPreference);
@Test
public void updateState_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
+ Settings.Global.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
StayAwakePreferenceController.SETTING_VALUE_OFF);
mController.updateState(mPreference);
@Test
public void observerOnChangeCalledWithSameUri_preferenceShouldBeUpdated() {
- Settings.System.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
+ Settings.Global.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
StayAwakePreferenceController.SETTING_VALUE_ON);
mController.onResume();
mController.mSettingsObserver.onChange(false,
@Test
public void observerOnChangeCalledWithDifferentUri_preferenceShouldNotBeUpdated() {
- Settings.System.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
+ Settings.Global.putInt(mContentResolver, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
StayAwakePreferenceController.SETTING_VALUE_ON);
mController.onResume();
mController.mSettingsObserver.onChange(false, null);
public void onPreferenceChanged_settingEnabled_turnOnTetheringAccel() {
mController.onPreferenceChange(mPreference, true /* new value */);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.TETHER_OFFLOAD_DISABLED, -1 /* default */);
assertThat(mode).isEqualTo(TetheringHardwareAccelPreferenceController.SETTING_VALUE_ON);
public void onPreferenceChanged_settingDisabled_turnOffTetheringAccel() {
mController.onPreferenceChange(mPreference, false /* new value */);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.TETHER_OFFLOAD_DISABLED, -1 /* default */);
assertThat(mode).isEqualTo(TetheringHardwareAccelPreferenceController.SETTING_VALUE_OFF);
@Test
public void updateState_settingEnabled_preferenceShouldBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.TETHER_OFFLOAD_DISABLED,
TetheringHardwareAccelPreferenceController.SETTING_VALUE_ON);
mController.updateState(mPreference);
@Test
public void updateState_settingDisabled_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.TETHER_OFFLOAD_DISABLED,
TetheringHardwareAccelPreferenceController.SETTING_VALUE_OFF);
mController.updateState(mPreference);
@Test
public void onDeveloperOptionsSwitchDisabled_shouldDisablePreference() {
mController.onDeveloperOptionsSwitchDisabled();
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.TETHER_OFFLOAD_DISABLED, -1 /* default */);
assertThat(mode).isEqualTo(TetheringHardwareAccelPreferenceController.SETTING_VALUE_OFF);
public void onPreferenceChanged_turnOnWifiDisplayCertification() {
mController.onPreferenceChange(mPreference, true /* new value */);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, -1 /* default */);
assertThat(mode).isEqualTo(WifiDisplayCertificationPreferenceController.SETTING_VALUE_ON);
public void onPreferenceChanged_turnOffWifiDisplayCertification() {
mController.onPreferenceChange(mPreference, false /* new value */);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, -1 /* default */);
assertThat(mode).isEqualTo(WifiDisplayCertificationPreferenceController.SETTING_VALUE_OFF);
@Test
public void updateState_preferenceShouldBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON,
WifiDisplayCertificationPreferenceController.SETTING_VALUE_ON);
mController.updateState(mPreference);
@Test
public void updateState_preferenceShouldNotBeChecked() {
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON,
WifiDisplayCertificationPreferenceController.SETTING_VALUE_OFF);
mController.updateState(mPreference);
@Test
public void onDeveloperOptionsDisabled_shouldDisablePreference() {
mController.onDeveloperOptionsDisabled();
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
+ final int mode = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, -1 /* default */);
assertThat(mode).isEqualTo(WifiDisplayCertificationPreferenceController.SETTING_VALUE_OFF);
import android.content.ComponentName;
import android.content.pm.PackageManager;
+import android.os.UserManager;
import android.service.quicksettings.Tile;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.shadows.ShadowUserManager;
@RunWith(SettingsRobolectricTestRunner.class)
public class DevelopmentTilesTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
mService = spy(Robolectric.setupService(DevelopmentTiles.ShowLayout.class));
+ final ShadowUserManager um = Shadows.shadowOf(
+ RuntimeEnvironment.application.getSystemService(UserManager.class));
+ um.setIsAdminUser(true);
doReturn(mTile).when(mService).getQsTile();
}
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
- final UserManager userManager =
- (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- mShadowUserManager = Shadows.shadowOf(userManager);
- mShadowUserManager.setIsAdminUser(true);
+ mShadowUserManager = Shadows.shadowOf(
+ RuntimeEnvironment.application.getSystemService(UserManager.class));
mFactory = FakeFeatureFactory.setupForTest();
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
@After
public void tearDown() {
ShadowUtils.reset();
- mShadowUserManager.setIsAdminUser(false);
- mShadowUserManager.setIsDemoUser(false);
}
@Test
@Test
public void onActivityResult_confirmPasswordRequestCompleted_enableDevPref() {
+ mShadowUserManager.setIsAdminUser(true);
mController =
new BuildNumberPreferenceController(mContext, mActivity, mFragment, mLifecycle);
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.WIFI_SERVICE, mWifiManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mPreference = new ValidatedEditTextPreference(mContext);
when(mScreen.findPreference(anyString())).thenReturn(mPreference);
final WifiConfiguration configuration = new WifiConfiguration();
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.storage.VolumeInfo;
import android.view.Menu;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
when(mMigrateMenuItem.getItemId()).thenReturn(100);
mController = new PrivateVolumeOptionMenuController(
- RuntimeEnvironment.application, mPrimaryInfo, mPm);
+ Robolectric.setupActivity(Activity.class), mPrimaryInfo, mPm);
}
@Test
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Build;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import org.robolectric.util.ReflectionHelpers;
import java.util.Collections;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
when(mDialog.getContext()).thenReturn(mContext);
}
@Test
public void onClick_noActivityIntent_shouldDoNothing() {
when(mPackageManager.queryIntentActivities(any(), anyInt()))
- .thenReturn(Collections.emptyList());
+ .thenReturn(Collections.emptyList());
mController = new SecurityPatchLevelDialogController(mDialog);
ReflectionHelpers.setField(mController, "mPackageManager", mPackageManager);
@Test
public void onClick_activityIntentFound_shouldStartActivity() {
when(mPackageManager.queryIntentActivities(any(), anyInt()))
- .thenReturn(Collections.singletonList(null));
+ .thenReturn(Collections.singletonList(null));
mController = new SecurityPatchLevelDialogController(mDialog);
ReflectionHelpers.setField(mController, "mPackageManager", mPackageManager);
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
import android.os.storage.VolumeInfo;
import android.text.format.Formatter;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
import java.io.File;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {
- SettingsShadowResources.class,
- SettingsShadowResources.SettingsShadowTheme.class
+ SettingsShadowResources.class,
+ SettingsShadowResources.SettingsShadowTheme.class
})
public class StorageSummaryDonutPreferenceControllerTest {
public void setUp() throws Exception {
SettingsShadowResources.overrideResource(
com.android.internal.R.string.config_headlineFontFamily, "");
- mContext = spy(RuntimeEnvironment.application.getApplicationContext());
+ mContext = spy(Robolectric.setupActivity(Activity.class));
mFakeFeatureFactory = FakeFeatureFactory.setupForTest();
mMetricsFeatureProvider = mFakeFeatureFactory.getMetricsFeatureProvider();
mController = new StorageSummaryDonutPreferenceController(mContext);
LayoutInflater inflater = LayoutInflater.from(mContext);
final View view =
- inflater.inflate(mPreference.getLayoutResource(), new LinearLayout(mContext), false);
+ inflater.inflate(mPreference.getLayoutResource(), new LinearLayout(mContext),
+ false);
mHolder = PreferenceViewHolder.createInstanceForTests(view);
}
}
@Test
- public void testEmpty() throws Exception {
+ public void testEmpty() {
final long totalSpace = 32 * GIGABYTE;
final long usedSpace = 0;
mController.updateBytes(0, 32 * GIGABYTE);
mController.updateState(mPreference);
final Formatter.BytesResult usedSpaceResults =
- Formatter.formatBytes(mContext.getResources(), usedSpace, 0 /* flags */);
+ Formatter.formatBytes(mContext.getResources(), usedSpace, 0 /* flags */);
assertThat(mPreference.getTitle().toString())
- .isEqualTo(usedSpaceResults.value + " " + usedSpaceResults.units);
+ .isEqualTo(usedSpaceResults.value + " " + usedSpaceResults.units);
assertThat(mPreference.getSummary().toString())
- .isEqualTo("Used of " + Formatter.formatShortFileSize(mContext, totalSpace));
+ .isEqualTo("Used of " + Formatter.formatShortFileSize(mContext, totalSpace));
}
@Test
- public void testTotalStorage() throws Exception {
+ public void testTotalStorage() {
final long totalSpace = KILOBYTE * 10;
final long usedSpace = KILOBYTE;
mController.updateBytes(KILOBYTE, totalSpace);
mController.updateState(mPreference);
final Formatter.BytesResult usedSpaceResults =
- Formatter.formatBytes(mContext.getResources(), usedSpace, 0 /* flags */);
+ Formatter.formatBytes(mContext.getResources(), usedSpace, 0 /* flags */);
assertThat(mPreference.getTitle().toString())
- .isEqualTo(usedSpaceResults.value + " " + usedSpaceResults.units);
+ .isEqualTo(usedSpaceResults.value + " " + usedSpaceResults.units);
assertThat(mPreference.getSummary().toString())
- .isEqualTo("Used of " + Formatter.formatShortFileSize(mContext, totalSpace));
+ .isEqualTo("Used of " + Formatter.formatShortFileSize(mContext, totalSpace));
}
@Test
- public void testPopulateWithVolume() throws Exception {
+ public void testPopulateWithVolume() {
final long totalSpace = KILOBYTE * 10;
final long freeSpace = KILOBYTE;
final long usedSpace = totalSpace - freeSpace;
mController.updateState(mPreference);
final Formatter.BytesResult usedSpaceResults =
- Formatter.formatBytes(mContext.getResources(), usedSpace, 0 /* flags */);
+ Formatter.formatBytes(mContext.getResources(), usedSpace, 0 /* flags */);
assertThat(mPreference.getTitle().toString())
- .isEqualTo(usedSpaceResults.value + " " + usedSpaceResults.units);
+ .isEqualTo(usedSpaceResults.value + " " + usedSpaceResults.units);
assertThat(mPreference.getSummary().toString())
- .isEqualTo("Used of " + Formatter.formatShortFileSize(mContext, totalSpace));
+ .isEqualTo("Used of " + Formatter.formatShortFileSize(mContext, totalSpace));
}
@Test
- public void testFreeUpSpaceMetricIsTriggered() throws Exception {
+ public void testFreeUpSpaceMetricIsTriggered() {
mPreference.onBindViewHolder(mHolder);
final Button button = (Button) mHolder.findViewById(R.id.deletion_helper_button);
mPreference.onClick(button);
verify(mMetricsFeatureProvider, times(1))
- .action(any(Context.class), eq(MetricsEvent.STORAGE_FREE_UP_SPACE_NOW));
+ .action(any(Context.class), eq(MetricsEvent.STORAGE_FREE_UP_SPACE_NOW));
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.UserInfo;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class UserProfileControllerTest {
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
mPrimaryProfile = new UserInfo();
mController = new UserProfileController(mContext, mPrimaryProfile, 0);
when(mScreen.getContext()).thenReturn(mContext);
}
@Test
- public void controllerAddsPrimaryProfilePreference() throws Exception {
+ public void controllerAddsPrimaryProfilePreference() {
final ArgumentCaptor<Preference> argumentCaptor = ArgumentCaptor.forClass(Preference.class);
verify(mScreen).addPreference(argumentCaptor.capture());
final Preference preference = argumentCaptor.getValue();
}
@Test
- public void tappingProfilePreferenceSendsToStorageProfileFragment() throws Exception {
+ public void tappingProfilePreferenceSendsToStorageProfileFragment() {
final ArgumentCaptor<Preference> argumentCaptor = ArgumentCaptor.forClass(Preference.class);
verify(mScreen).addPreference(argumentCaptor.capture());
}
@Test
- public void acceptingResultUpdatesPreferenceSize() throws Exception {
+ public void acceptingResultUpdatesPreferenceSize() {
final SparseArray<StorageAsyncLoader.AppsStorageResult> result = new SparseArray<>();
final StorageAsyncLoader.AppsStorageResult userResult =
new StorageAsyncLoader.AppsStorageResult();
}
@Test
- public void iconCallbackChangesPreferenceIcon() throws Exception {
+ public void iconCallbackChangesPreferenceIcon() {
final SparseArray<Drawable> icons = new SparseArray<>();
final UserIconDrawable drawable = mock(UserIconDrawable.class);
when(drawable.mutate()).thenReturn(drawable);
@Before
public void setUp() {
- mActivity = Robolectric.buildActivity(CustomActivity.class).get();
+ mActivity = Robolectric.setupActivity(CustomActivity.class);
mActivityShadow = Shadow.extract(mActivity);
mHelper = new ActionDisabledByAdminDialogHelper(mActivity);
}
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
+import android.app.Activity;
import android.app.AppOpsManager;
import android.content.Context;
import android.content.Intent;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import java.util.ArrayList;
import java.util.List;
mOtherUserPackageOps = new AppOpsManager.PackageOps(
RESTRICTED_PACKAGE_NAME, OTHER_USER_UID, restrictedOps);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
doReturn(mAppOpsManager).when(mContext).getSystemService(Context.APP_OPS_SERVICE);
doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
doReturn(mContext).when(mFragment).getContext();
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.Activity;
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import java.util.ArrayList;
import java.util.List;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = RuntimeEnvironment.application;
+ mContext = Robolectric.setupActivity(Activity.class);
mAppInfos = new ArrayList<>();
mAppInfos.add(new AppInfo.Builder()
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
+import com.android.settingslib.testutils.DrawableTestHelper;
import org.junit.Before;
import org.junit.Test;
assertThat(preference.getTitle()).isEqualTo(TITLE);
assertThat(preference.getSummary()).isEqualTo(SUMMARY);
- assertThat(preference.getIcon()).isEqualTo(mContext.getDrawable(ICON_ID));
+ DrawableTestHelper.assertDrawableResId(preference.getIcon(), ICON_ID);
}
@Test
@Test
public void testIsChecked_configIsNotSet_shouldReturnTrue() {
// Set the setting to be enabled.
- Settings.System.putInt(mContentResolver, CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, ON);
+ Settings.Secure.putInt(mContentResolver, CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, ON);
mController = new DoubleTapPowerPreferenceController(mContext, KEY_DOUBLE_TAP_POWER);
assertThat(mController.isChecked()).isTrue();
@Test
public void testIsChecked_configIsSet_shouldReturnFalse() {
// Set the setting to be disabled.
- Settings.System.putInt(mContentResolver, CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, OFF);
+ Settings.Secure.putInt(mContentResolver, CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, OFF);
mController = new DoubleTapPowerPreferenceController(mContext, KEY_DOUBLE_TAP_POWER);
assertThat(mController.isChecked()).isFalse();
public void testIsChecked_configIsSet_shouldReturnTrue() {
// Set the setting to be enabled.
final Context context = RuntimeEnvironment.application;
- Settings.System.putInt(context.getContentResolver(),
+ Settings.Secure.putInt(context.getContentResolver(),
Settings.Secure.CAMERA_DOUBLE_TWIST_TO_FLIP_ENABLED, 1);
mController = new DoubleTwistPreferenceController(context, KEY_DOUBLE_TWIST);
public void testIsChecked_configIsNotSet_shouldReturnFalse() {
// Set the setting to be disabled.
final Context context = RuntimeEnvironment.application;
- Settings.System.putInt(context.getContentResolver(),
+ Settings.Secure.putInt(context.getContentResolver(),
Settings.Secure.CAMERA_DOUBLE_TWIST_TO_FLIP_ENABLED, 0);
mController = new DoubleTwistPreferenceController(context, KEY_DOUBLE_TWIST);
when(mFingerprintManager.isHardwareDetected()).thenReturn(true);
// Set the setting to be enabled.
final Context context = RuntimeEnvironment.application;
- Settings.System.putInt(context.getContentResolver(), SYSTEM_NAVIGATION_KEYS_ENABLED, 1);
+ Settings.Secure.putInt(context.getContentResolver(), SYSTEM_NAVIGATION_KEYS_ENABLED, 1);
mController = new SwipeToNotificationPreferenceController(context, KEY_SWIPE_DOWN);
assertThat(mController.isChecked()).isTrue();
when(mFingerprintManager.isHardwareDetected()).thenReturn(true);
// Set the setting to be disabled.
final Context context = RuntimeEnvironment.application;
- Settings.System.putInt(context.getContentResolver(), SYSTEM_NAVIGATION_KEYS_ENABLED, 0);
+ Settings.Secure.putInt(context.getContentResolver(), SYSTEM_NAVIGATION_KEYS_ENABLED, 0);
mController = new SwipeToNotificationPreferenceController(context, KEY_SWIPE_DOWN);
assertThat(mController.isChecked()).isFalse();
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
+import android.content.pm.ApplicationInfo;
import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
import com.android.internal.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
mContext.getString(com.android.internal.R.string.config_recentsComponentName));
final Intent quickStepIntent = new Intent(ACTION_QUICKSTEP)
.setPackage(recentsComponentName.getPackageName());
- mPackageManager.addResolveInfoForIntent(quickStepIntent, new ResolveInfo());
+ final ResolveInfo info = new ResolveInfo();
+ info.serviceInfo = new ServiceInfo();
+ info.resolvePackageName = recentsComponentName.getPackageName();
+ info.serviceInfo.packageName = info.resolvePackageName;
+ info.serviceInfo.name = recentsComponentName.getClassName();
+ info.serviceInfo.applicationInfo = new ApplicationInfo();
+ info.serviceInfo.applicationInfo.flags = ApplicationInfo.FLAG_SYSTEM;
+ mPackageManager.addResolveInfoForIntent(quickStepIntent, info);
assertThat(SwipeUpPreferenceController.isGestureAvailable(mContext)).isTrue();
}
@Test
public void isSliceableCorrectKey_returnsTrue() {
final SwipeUpPreferenceController controller =
- new SwipeUpPreferenceController(mContext,"gesture_swipe_up");
+ new SwipeUpPreferenceController(mContext, "gesture_swipe_up");
assertThat(controller.isSliceable()).isTrue();
}
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
+import android.app.Activity;
+import android.content.ComponentName;
import android.content.Context;
-import android.content.Intent;
import android.net.NetworkPolicyManager;
import com.android.settings.Settings;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowActivity;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
private ConditionManager mConditionManager;
@Mock
private NetworkPolicyManager mNetworkPolicyManager;
- private Context mContext;
+ private Activity mActivity;
private BackgroundDataConditionController mController;
@Before
MockitoAnnotations.initMocks(this);
ShadowApplication.getInstance().setSystemService(Context.NETWORK_POLICY_SERVICE,
mNetworkPolicyManager);
- mContext = spy(RuntimeEnvironment.application);
- mController = new BackgroundDataConditionController(mContext, mConditionManager);
+ mActivity = Robolectric.setupActivity(Activity.class);
+ mController = new BackgroundDataConditionController(mActivity, mConditionManager);
}
@Test
public void onPrimaryClick_shouldReturn2SummaryActivity() {
- final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
- mController.onPrimaryClick(mContext);
- verify(mContext).startActivity(argumentCaptor.capture());
- Intent intent = argumentCaptor.getValue();
+ final ComponentName componentName =
+ new ComponentName(mActivity, Settings.DataUsageSummaryActivity.class);
- assertThat(intent.getComponent().getClassName()).isEqualTo(
- Settings.DataUsageSummaryActivity.class.getName());
+ mController.onPrimaryClick(mActivity);
+
+ final ShadowActivity shadowActivity = Shadow.extract(mActivity);
+ assertThat(shadowActivity.getNextStartedActivity().getComponent()).isEqualTo(componentName);
}
@Test
package com.android.settings.homepage.contextualcards.conditional;
-import static org.mockito.ArgumentMatchers.argThat;
+import static com.google.common.truth.Truth.assertThat;
+
import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
+import android.app.Activity;
import android.content.ComponentName;
-import android.content.Context;
import com.android.settings.Settings;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowActivity;
@RunWith(SettingsRobolectricTestRunner.class)
public class WorkModeConditionControllerTest {
@Mock
private ConditionManager mConditionManager;
- private Context mContext;
+ private Activity mActivity;
private WorkModeConditionController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
- mController = new WorkModeConditionController(mContext, mConditionManager);
+ mActivity = spy(Robolectric.setupActivity(Activity.class));
+ mController = new WorkModeConditionController(mActivity, mConditionManager);
}
@Test
public void onPrimaryClick_shouldLaunchAccountsSetting() {
final ComponentName componentName =
- new ComponentName(mContext, Settings.AccountDashboardActivity.class);
+ new ComponentName(mActivity, Settings.AccountDashboardActivity.class);
- mController.onPrimaryClick(mContext);
+ mController.onPrimaryClick(mActivity);
- verify(mContext).startActivity(
- argThat(intent -> intent.getComponent().equals(componentName)));
+ final ShadowActivity shadowActivity = Shadow.extract(mActivity);
+ assertThat(shadowActivity.getNextStartedActivity().getComponent()).isEqualTo(componentName);
}
}
@Test
public void isAvailable_noLocationLinkPermission_shouldReturnFalse() {
- Settings.System.putInt(mContext.getContentResolver(),
- android.provider.Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED, 0);
+ Settings.Global.putInt(mContext.getContentResolver(),
+ Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED, 0);
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void displayPreference_hasLocationLinkPermission_shouldReturnTrue() {
- Settings.System.putInt(mContext.getContentResolver(),
- android.provider.Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED, 1);
+ Settings.Global.putInt(mContext.getContentResolver(),
+ Settings.Global.LOCATION_SETTINGS_LINK_TO_PERMISSIONS_ENABLED, 1);
assertThat(mController.isAvailable()).isTrue();
}
import static org.mockito.Mockito.when;
import static org.robolectric.shadow.api.Shadow.extract;
+import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager);
import static org.mockito.Mockito.when;
import android.content.Context;
+import android.os.UserManager;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowUserManager;
import org.robolectric.util.ReflectionHelpers;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = ShadowRestrictedLockUtilsInternal.class)
public class TopLevelNetworkEntryPreferenceControllerTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
+ final ShadowUserManager um = Shadows.shadowOf(
+ RuntimeEnvironment.application.getSystemService(UserManager.class));
+ um.setIsAdminUser(true);
+
mController = new TopLevelNetworkEntryPreferenceController(mContext, "test_key");
ReflectionHelpers.setField(mController, "mWifiPreferenceController",
mMobileNetworkPreferenceController);
ReflectionHelpers.setField(mController, "mTetherPreferenceController",
mTetherPreferenceController);
-
}
@Test
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.PersistableBundle;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class ApnPreferenceControllerTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE);
doReturn(mSubscriptionManager).when(mContext).getSystemService(SubscriptionManager.class);
doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID);
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class DataServiceSetupPreferenceControllerTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE);
doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID);
doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId(
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.provider.Settings;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class DataUsagePreferenceControllerTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE);
doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID);
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.telephony.TelephonyManager;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class EuiccPreferenceControllerTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
+ mContext = spy(Robolectric.setupActivity(Activity.class));
doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE);
doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID);
import org.junit.runner.RunWith;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
-import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
@RunWith(SettingsRobolectricTestRunner.class)
@Before
public void setUp() {
- mContext = ShadowApplication.getInstance().getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mNfcAdapter = NfcAdapter.getDefaultAdapter(mContext);
- mNfcPreference = new SwitchPreference(RuntimeEnvironment.application);
+ mNfcPreference = new SwitchPreference(mContext);
mNfcAirplaneModeObserver =
new NfcAirplaneModeObserver(mContext, mNfcAdapter, mNfcPreference);
final ContentResolver contentResolver = mContext.getContentResolver();
Settings.Global.putInt(contentResolver, Settings.Global.AIRPLANE_MODE_ON, 1);
Settings.Global.putString(contentResolver,
- Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS, Settings.Global.RADIO_NFC);
+ Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS, Settings.Global.RADIO_NFC);
mNfcAirplaneModeObserver.onChange(false, NfcAirplaneModeObserver.AIRPLANE_MODE_URI);
final ContentResolver contentResolver = mContext.getContentResolver();
Settings.Global.putInt(contentResolver, Settings.Global.AIRPLANE_MODE_ON, 1);
Settings.Global.putString(contentResolver,
- Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS, Global.RADIO_WIFI);
+ Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS, Global.RADIO_WIFI);
mNfcAirplaneModeObserver.onChange(false, NfcAirplaneModeObserver.AIRPLANE_MODE_URI);
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = spy(new BlockPreferenceController(mContext, mImportanceListener, mBackend));
mSwitch = new SwitchBar(mContext);
when(mPreference.findViewById(R.id.switch_bar)).thenReturn(mSwitch);
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
+import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.shadows.ShadowSystemProperties;
@RunWith(SettingsRobolectricTestRunner.class)
public class BootSoundPreferenceControllerTest {
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- when(mContext.getResources().getBoolean(com.android.settings.R.bool.has_boot_sounds))
- .thenReturn(true);
+ when(mContext.getResources().getBoolean(R.bool.has_boot_sounds))
+ .thenReturn(true);
mController = new BootSoundPreferenceController(mContext);
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
when(mPreference.getKey()).thenReturn(mController.getPreferenceKey());
@Test
public void isAvailable_hasBootSounds_shouldReturnTrue() {
when(mContext.getResources().getBoolean(
- com.android.settings.R.bool.has_boot_sounds)).thenReturn(true);
+ R.bool.has_boot_sounds)).thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_noBootSounds_shouldReturnFale() {
when(mContext.getResources().getBoolean(
- com.android.settings.R.bool.has_boot_sounds)).thenReturn(false);
+ R.bool.has_boot_sounds)).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void displayPreference_bootSoundEnabled_shouldCheckedPreference() {
- ShadowSystemProperties.native_set(BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, "1");
-
+ SystemProperties.set(BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, "true");
mController.displayPreference(mScreen);
verify(mPreference).setChecked(true);
@Test
public void displayPreference_bootSoundDisabled_shouldUncheckedPreference() {
- ShadowSystemProperties.native_set(BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, "0");
+ SystemProperties.set(BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, "0");
mController.displayPreference(mScreen);
mController.handlePreferenceTreeClick(mPreference);
assertThat(SystemProperties.get(
- BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, null)).isEqualTo("1");
+ BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, null)).isEqualTo("1");
}
@Test
mController.handlePreferenceTreeClick(mPreference);
assertThat(SystemProperties.get(
- BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, null)).isEqualTo("0");
+ BootSoundPreferenceController.PROPERTY_BOOT_SOUNDS, null)).isEqualTo("0");
}
}
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = new DeletedChannelsPreferenceController(mContext, mBackend);
}
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = spy(new DescriptionPreferenceController(mContext));
}
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
PreferenceFragmentCompat fragment = mock(PreferenceFragmentCompat.class);
when(fragment.getContext()).thenReturn(mContext);
FragmentActivity activity = mock(FragmentActivity.class);
// By default allow lights
SettingsShadowResources.overrideResource(
com.android.internal.R.bool.config_intrusiveNotificationLed, true);
- Settings.Secure.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 1);
+ Settings.System.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 1);
}
@Test
@Test
public void testIsAvailable_notIfSettingNotAllowed() {
- Settings.Secure.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 0);
+ Settings.System.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 0);
NotificationBackend.AppRow appRow = new NotificationBackend.AppRow();
NotificationChannel channel = new NotificationChannel("", "", IMPORTANCE_DEFAULT);
mController.onResume(appRow, channel, null, null);
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
@RunWith(SettingsRobolectricTestRunner.class)
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = new TestPreferenceController(mContext, mBackend);
}
@Test
public void isChecked_configOn_shouldReturnTrue() {
- Settings.Secure.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 1);
+ Settings.System.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 1);
assertThat(mController.isChecked()).isTrue();
}
@Test
public void isChecked_configOff_shouldReturnFalse() {
- Settings.Secure.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 0);
+ Settings.System.putInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 0);
assertThat(mController.isChecked()).isFalse();
}
assertThat(mController.isChecked()).isTrue();
assertThat(
- Settings.Secure.getInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 0))
+ Settings.System.getInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 0))
.isEqualTo(1);
}
assertThat(mController.isChecked()).isFalse();
assertThat(
- Settings.Secure.getInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 1))
+ Settings.System.getInt(mContext.getContentResolver(), NOTIFICATION_LIGHT_PULSE, 1))
.isEqualTo(0);
}
}
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;
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
SettingsShadowResources.overrideResource(com.android.internal.R.string.ringtone_silent,
"silent");
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = spy(new SoundPreferenceController(
mContext, mFragment, mImportanceListener, mBackend));
}
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
shadowApplication.setSystemService(Context.DEVICE_POLICY_SERVICE, mDm);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = spy(new VisibilityPreferenceController(mContext, mLockUtils, mBackend));
// by default the lockscreen is secure
mController.updateState(pref);
ArgumentCaptor<CharSequence[]> argumentCaptor =
- ArgumentCaptor.forClass(CharSequence[].class);
+ ArgumentCaptor.forClass(CharSequence[].class);
verify(pref, times(1)).setEntryValues(argumentCaptor.capture());
assertFalse(toStringList(argumentCaptor.getValue())
.contains(String.valueOf(VISIBILITY_NO_OVERRIDE)));
mController.updateState(pref);
ArgumentCaptor<CharSequence[]> argumentCaptor =
- ArgumentCaptor.forClass(CharSequence[].class);
+ ArgumentCaptor.forClass(CharSequence[].class);
verify(pref, times(1)).setEntryValues(argumentCaptor.capture());
assertEquals(2, toStringList(argumentCaptor.getValue()).size());
assertFalse(toStringList(argumentCaptor.getValue())
mController.updateState(pref);
ArgumentCaptor<CharSequence[]> argumentCaptor =
- ArgumentCaptor.forClass(CharSequence[].class);
+ ArgumentCaptor.forClass(CharSequence[].class);
verify(pref, times(1)).setEntryValues(argumentCaptor.capture());
List<String> values = toStringList(argumentCaptor.getValue());
assertEquals(3, values.size());
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
private Context mContext;
@Mock
private PreferenceScreen mScreen;
- @Mock NotificationManager mNotificationManager;
+ @Mock
+ NotificationManager mNotificationManager;
private static final String PREF_KEY = "main_pref";
public void setup() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
when(mNotificationManager.getNotificationPolicy()).thenReturn(
mock(NotificationManager.Policy.class));
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
mController = new ZenModeAlarmsPreferenceController(mContext, mock(Lifecycle.class));
ReflectionHelpers.setField(mController, "mBackend", mBackend);
when(mPreferenceScreen.findPreference(mController.getPreferenceKey()))
- .thenReturn(mockPref);
+ .thenReturn(mockPref);
mController.displayPreference(mPreferenceScreen);
}
mController.onPreferenceChange(mockPref, allowAlarms);
verify(mBackend)
- .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS, allowAlarms);
+ .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS, allowAlarms);
}
@Test
mController.onPreferenceChange(mockPref, allowAlarms);
verify(mBackend)
- .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS, allowAlarms);
+ .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS, allowAlarms);
}
}
\ No newline at end of file
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getZenModeConfig()).thenReturn(mZenModeConfig);
ReflectionHelpers.setField(mController, "mZenModeConfigWrapper", mConfigWrapper);
when(mPreferenceScreen.findPreference(mController.getPreferenceKey()))
- .thenReturn(mockPref);
+ .thenReturn(mockPref);
mController.displayPreference(mPreferenceScreen);
}
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
mController = new ZenModeButtonPreferenceController(mContext, mock(Lifecycle.class),
mock(FragmentManager.class));
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mValues = mContext.getResources().getStringArray(R.array.zen_mode_contacts_values);
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
when(mBackend.getPriorityCallSenders())
- .thenReturn(NotificationManager.Policy.PRIORITY_SENDERS_STARRED);
+ .thenReturn(NotificationManager.Policy.PRIORITY_SENDERS_STARRED);
when(mBackend.getContactsSummary(ZenModeBackend.SOURCE_NONE))
.thenCallRealMethod();
when(mBackend.getContactsSummary(NotificationManager.Policy.PRIORITY_CATEGORY_CALLS))
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
mController = new ZenModeDurationPreferenceController(mContext, mock(Lifecycle.class));
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
import android.content.Intent;
import android.content.res.Resources;
+import androidx.fragment.app.FragmentActivity;
+
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
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;
import org.robolectric.shadows.ShadowToast;
import java.util.ArrayList;
import java.util.List;
-import androidx.fragment.app.FragmentActivity;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = SettingsShadowResources.SettingsShadowTheme.class)
public class ZenModeEventRuleSettingsTest {
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mFragment = spy(new TestFragment());
mFragment.onAttach(application);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
ReflectionHelpers.setField(mController, "mBackend", mBackend);
when(mPreferenceScreen.findPreference(mController.getPreferenceKey()))
- .thenReturn(mockPref);
+ .thenReturn(mockPref);
mController.displayPreference(mPreferenceScreen);
}
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mValues = mContext.getResources().getStringArray(R.array.zen_mode_contacts_values);
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
when(mBackend.getPriorityMessageSenders())
- .thenReturn(NotificationManager.Policy.PRIORITY_SENDERS_STARRED);
+ .thenReturn(NotificationManager.Policy.PRIORITY_SENDERS_STARRED);
when(mBackend.getContactsSummary(ZenModeBackend.SOURCE_NONE))
.thenCallRealMethod();
when(mBackend.getContactsSummary(NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES))
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = new ZenModePreferenceController(mContext, KEY_ZEN_MODE);
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
mSummaryBuilder = spy(new ZenModeSettings.SummaryBuilder(mContext));
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
ReflectionHelpers.setField(mController, "mBackend", mBackend);
when(mPreferenceScreen.findPreference(mController.getPreferenceKey()))
- .thenReturn(mockPref);
+ .thenReturn(mockPref);
mController.displayPreference(mPreferenceScreen);
}
mController.onPreferenceChange(mockPref, allow);
verify(mBackend)
- .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REMINDERS, allow);
+ .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REMINDERS, allow);
}
@Test
mController.onPreferenceChange(mockPref, allow);
verify(mBackend)
- .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REMINDERS, allow);
+ .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REMINDERS, allow);
}
}
\ No newline at end of file
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
mController.onPreferenceChange(mockPref, allow);
verify(mBackend)
- .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REPEAT_CALLERS, allow);
+ .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REPEAT_CALLERS,
+ allow);
}
@Test
mController.onPreferenceChange(mockPref, allow);
verify(mBackend)
- .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REPEAT_CALLERS, allow);
+ .saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_REPEAT_CALLERS,
+ allow);
}
}
\ No newline at end of file
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;
import org.robolectric.shadows.ShadowToast;
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mFragment = spy(new TestFragment());
mFragment.onAttach(application);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getZenModeConfig()).thenReturn(mZenModeConfig);
mController =
- new ZenModeSettingsFooterPreferenceController(mContext, mock(Lifecycle.class));
+ new ZenModeSettingsFooterPreferenceController(mContext, mock(Lifecycle.class));
ReflectionHelpers.setField(mZenModeConfig, AUTOMATIC_RULES_FIELD, mInjectedAutomaticRules);
ReflectionHelpers.setField(mController, "mZenModeConfigWrapper", mConfigWrapper);
injectedManualRule.conditionId = mock(Uri.class);
when(mConfigWrapper.parseManualRuleTime(injectedManualRule.conditionId)).thenReturn(time);
when(mConfigWrapper.getFormattedTime(time, mContext.getUserId()))
- .thenReturn(timePlaceholder);
+ .thenReturn(timePlaceholder);
ReflectionHelpers.setField(mZenModeConfig, MANUAL_RULE_FIELD, injectedManualRule);
}
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
when(testIntent.resolveActivity(any())).thenReturn(mComponentName);
// expected - no null values
List<String> contacts = mMessagesController.getStarredContacts(testCursorWithNullValues);
- for (int i = 0 ; i < contacts.size(); i++) {
- assertThat(contacts.get(i)).isNotNull();
+ for (String contact : contacts) {
+ assertThat(contact).isNotNull();
}
}
doAnswer(new Answer<Boolean>() {
int count = 0;
+
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
if (count < size) {
ShadowApplication shadowApplication = ShadowApplication.getInstance();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mContentResolver = RuntimeEnvironment.application.getContentResolver();
when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
mController = new ZenModeSystemPreferenceController(mContext, mock(Lifecycle.class));
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
private FakeFeatureFactory mFeatureFactory;
@Mock
private PreferenceScreen mScreen;
- @Mock NotificationManager mNotificationManager;
+ @Mock
+ NotificationManager mNotificationManager;
private static final String PREF_KEY = "main_pref";
private static final int PREF_METRICS = 1;
public void setup() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mFeatureFactory = FakeFeatureFactory.setupForTest();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
when(mNotificationManager.getNotificationPolicy()).thenReturn(
public void updateState_checkedFalse_parentChecked() {
mController = new ZenModeVisEffectPreferenceController(mContext, mock(Lifecycle.class),
PREF_KEY, SUPPRESSED_EFFECT_PEEK, PREF_METRICS,
- new int[] {PARENT_EFFECT1, PARENT_EFFECT2});
+ new int[]{PARENT_EFFECT1, PARENT_EFFECT2});
ReflectionHelpers.setField(mController, "mBackend", mBackend);
when(mBackend.isVisualEffectSuppressed(SUPPRESSED_EFFECT_PEEK)).thenReturn(false);
when(mBackend.isVisualEffectSuppressed(PARENT_EFFECT1)).thenReturn(false);
public void updateState_checkedFalse_parentNotChecked() {
mController = new ZenModeVisEffectPreferenceController(mContext, mock(Lifecycle.class),
PREF_KEY, SUPPRESSED_EFFECT_PEEK, PREF_METRICS,
- new int[] {PARENT_EFFECT1, PARENT_EFFECT2});
+ new int[]{PARENT_EFFECT1, PARENT_EFFECT2});
ReflectionHelpers.setField(mController, "mBackend", mBackend);
when(mBackend.isVisualEffectSuppressed(SUPPRESSED_EFFECT_PEEK)).thenReturn(false);
when(mBackend.isVisualEffectSuppressed(PARENT_EFFECT1)).thenReturn(false);
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
private FakeFeatureFactory mFeatureFactory;
@Mock
private PreferenceScreen mScreen;
- @Mock NotificationManager mNotificationManager;
+ @Mock
+ NotificationManager mNotificationManager;
private static final String PREF_KEY = "main_pref";
public void setup() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mFeatureFactory = FakeFeatureFactory.setupForTest();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
when(mNotificationManager.getNotificationPolicy()).thenReturn(
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
private FakeFeatureFactory mFeatureFactory;
@Mock
private PreferenceScreen mScreen;
- @Mock NotificationManager mNotificationManager;
+ @Mock
+ NotificationManager mNotificationManager;
private static final String PREF_KEY = "main_pref";
public void setup() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mFeatureFactory = FakeFeatureFactory.setupForTest();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
when(mNotificationManager.getNotificationPolicy()).thenReturn(
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
private FakeFeatureFactory mFeatureFactory;
@Mock
private PreferenceScreen mScreen;
- @Mock NotificationManager mNotificationManager;
+ @Mock
+ NotificationManager mNotificationManager;
private static final String PREF_KEY = "main_pref";
- private static final int PREF_METRICS = 1;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
- mContext = shadowApplication.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mFeatureFactory = FakeFeatureFactory.setupForTest();
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
when(mNotificationManager.getNotificationPolicy()).thenReturn(
import com.android.settings.testutils.shadow.SettingsShadowResources;
import com.android.settings.testutils.shadow.SettingsShadowResourcesImpl;
import com.android.settings.testutils.shadow.ShadowUtils;
+import com.android.settingslib.testutils.DrawableTestHelper;
import com.android.setupwizardlib.GlifLayout;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
-import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
-import org.robolectric.shadows.ShadowDrawable;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {
ChooseLockPattern activity = createActivity(true);
ChooseLockPatternFragment fragment = (ChooseLockPatternFragment)
activity.getSupportFragmentManager().findFragmentById(R.id.main_content);
-
- ShadowDrawable drawable = Shadows.shadowOf(((GlifLayout) fragment.getView()).getIcon());
- assertThat(drawable.getCreatedFromResId()).isEqualTo(R.drawable.ic_fingerprint_header);
+ DrawableTestHelper.assertDrawableResId(((GlifLayout) fragment.getView()).getIcon(),
+ R.drawable.ic_fingerprint_header);
}
@Config(qualifiers = "sw300dp")
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import java.util.ArrayList;
ShadowApplication application = ShadowApplication.getInstance();
application.setSystemService(Context.DEVICE_POLICY_SERVICE, mDevicePolicyManager);
application.setSystemService(Context.USER_SERVICE, mUserManager);
- mContext = application.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
}
@Test
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
-import android.os.UserManager;
import androidx.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowLockPatternUtils;
+import com.android.settings.testutils.shadow.ShadowUserManager;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
-@Config(shadows = ShadowLockPatternUtils.class)
+@Config(shadows = {ShadowLockPatternUtils.class, ShadowUserManager.class})
public class EncryptionStatusPreferenceControllerTest {
private Context mContext;
private EncryptionStatusPreferenceController mController;
private Preference mPreference;
+ private ShadowUserManager mShadowUserManager;
@Before
public void setUp() {
mContext = RuntimeEnvironment.application;
mController =
- new EncryptionStatusPreferenceController(mContext, PREF_KEY_ENCRYPTION_DETAIL_PAGE);
+ new EncryptionStatusPreferenceController(mContext, PREF_KEY_ENCRYPTION_DETAIL_PAGE);
+ mShadowUserManager = ShadowUserManager.getShadow();
mPreference = new Preference(mContext);
}
+ @After
+ public void tearDown() {
+ mShadowUserManager.reset();
+ }
+
@Test
public void isAvailable_admin_true() {
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- Shadows.shadowOf(userManager).setIsAdminUser(true);
+ mShadowUserManager.setIsAdminUser(true);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_notAdmin_false() {
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- Shadows.shadowOf(userManager).setIsAdminUser(false);
+ mShadowUserManager.setIsAdminUser(false);
assertThat(mController.isAvailable()).isFalse();
}
mController = new EncryptionStatusPreferenceController(mContext,
PREF_KEY_ENCRYPTION_SECURITY_PAGE);
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- Shadows.shadowOf(userManager).setIsAdminUser(true);
+ mShadowUserManager.setIsAdminUser(true);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void updateSummary_unencrypted_securityPage_shouldNotHaveEncryptionFragment() {
mController =
- new EncryptionStatusPreferenceController(mContext, PREF_KEY_ENCRYPTION_SECURITY_PAGE);
+ new EncryptionStatusPreferenceController(mContext,
+ PREF_KEY_ENCRYPTION_SECURITY_PAGE);
ShadowLockPatternUtils.setDeviceEncryptionEnabled(false);
mController.updateState(mPreference);
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.provider.Settings;
import android.provider.SettingsSlicesContract;
import android.util.ArraySet;
+import android.view.accessibility.AccessibilityManager;
import androidx.slice.Slice;
import androidx.slice.SliceProvider;
import com.android.settings.testutils.DatabaseTestUtils;
import com.android.settings.testutils.FakeToggleController;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
+import com.android.settings.testutils.shadow.ShadowLockPatternUtils;
import com.android.settings.testutils.shadow.ShadowThreadUtils;
+import com.android.settings.testutils.shadow.ShadowUserManager;
+import com.android.settings.testutils.shadow.ShadowUtils;
import com.android.settings.wifi.WifiSlice;
import org.junit.After;
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;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.annotation.Resetter;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowAccessibilityManager;
import java.io.IOException;
import java.util.ArrayList;
* TODO Investigate using ShadowContentResolver.registerProviderInternal(String, ContentProvider)
*/
@RunWith(SettingsRobolectricTestRunner.class)
-@Config(shadows = ShadowThreadUtils.class)
+@Config(shadows = {ShadowUserManager.class, ShadowThreadUtils.class, ShadowUtils.class,
+ SlicesDatabaseAccessorTest.ShadowApplicationPackageManager.class,
+ ShadowBluetoothAdapter.class, ShadowLockPatternUtils.class})
public class SettingsSliceProviderTest {
private static final String KEY = "KEY";
private Context mContext;
private SettingsSliceProvider mProvider;
- private SQLiteDatabase mDb;
+ @Mock
private SliceManager mManager;
private static final List<Uri> SPECIAL_CASE_PLATFORM_URIS = Arrays.asList(
@Before
public void setUp() {
+ MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
+ // Register the fake a11y Service
+ ShadowAccessibilityManager shadowAccessibilityManager = Shadow.extract(
+ RuntimeEnvironment.application.getSystemService(AccessibilityManager.class));
+ shadowAccessibilityManager.setInstalledAccessibilityServiceList(new ArrayList<>());
+
mProvider = spy(new SettingsSliceProvider());
ShadowStrictMode.reset();
mProvider.mSliceWeakDataCache = new HashMap<>();
mProvider.mCustomSliceManager = spy(new CustomSliceManager(mContext));
when(mProvider.getContext()).thenReturn(mContext);
- mDb = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
SlicesDatabaseHelper.getInstance(mContext).setIndexedState();
- mManager = mock(SliceManager.class);
- when(mContext.getSystemService(SliceManager.class)).thenReturn(mManager);
+
+ doReturn(mManager).when(mContext).getSystemService(SliceManager.class);
when(mManager.getPinnedSlices()).thenReturn(Collections.emptyList());
SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);
}
private void insertSpecialCase(String key, boolean isPlatformSlice) {
- ContentValues values = new ContentValues();
+ final ContentValues values = new ContentValues();
values.put(SlicesDatabaseHelper.IndexColumns.KEY, key);
values.put(SlicesDatabaseHelper.IndexColumns.TITLE, TITLE);
values.put(SlicesDatabaseHelper.IndexColumns.SUMMARY, "s");
values.put(SlicesDatabaseHelper.IndexColumns.CONTROLLER, PREF_CONTROLLER);
values.put(SlicesDatabaseHelper.IndexColumns.PLATFORM_SLICE, isPlatformSlice);
values.put(SlicesDatabaseHelper.IndexColumns.SLICE_TYPE, SliceData.SliceType.INTENT);
-
- mDb.replaceOrThrow(SlicesDatabaseHelper.Tables.TABLE_SLICES_INDEX, null, values);
+ final SQLiteDatabase db = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
+ db.beginTransaction();
+ try {
+ db.replaceOrThrow(SlicesDatabaseHelper.Tables.TABLE_SLICES_INDEX, null, values);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ db.close();
}
private static SliceData getDummyData() {
.build();
}
- @Implements(value = StrictMode.class, inheritImplementationMethods = true)
+ @Implements(value = StrictMode.class)
public static class ShadowStrictMode {
private static int sSetThreadPolicyCount;
import static org.mockito.Mockito.spy;
+import android.app.ApplicationPackageManager;
+import android.content.ComponentName;
import android.content.ContentValues;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.FakeIndexProvider;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
+import com.android.settings.testutils.shadow.ShadowLockPatternUtils;
+import com.android.settings.testutils.shadow.ShadowUserManager;
+import com.android.settings.testutils.shadow.ShadowUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
import org.robolectric.shadow.api.Shadow;
import org.robolectric.shadows.ShadowAccessibilityManager;
@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = {ShadowUserManager.class, ShadowUtils.class,
+ SlicesDatabaseAccessorTest.ShadowApplicationPackageManager.class,
+ ShadowBluetoothAdapter.class, ShadowLockPatternUtils.class})
public class SlicesDatabaseAccessorTest {
private final String FAKE_TITLE = "title";
@Before
public void setUp() {
mContext = RuntimeEnvironment.application;
+ ShadowUserManager.getShadow().setIsAdminUser(true);
mAccessor = spy(new SlicesDatabaseAccessor(mContext));
mDb = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
SlicesDatabaseHelper.getInstance(mContext).setIndexedState();
@After
public void cleanUp() {
+ ShadowUserManager.getShadow().reset();
DatabaseTestUtils.clearDb(mContext);
}
mDb.replaceOrThrow(SlicesDatabaseHelper.Tables.TABLE_SLICES_INDEX, null, values);
}
+
+ @Implements(ApplicationPackageManager.class)
+ public static class ShadowApplicationPackageManager extends
+ org.robolectric.shadows.ShadowApplicationPackageManager {
+
+ @Implementation
+ protected ComponentName getInstantAppResolverSettingsComponent() {
+ return null;
+ }
+ }
}
private SlicesIndexer mManager;
- private SQLiteDatabase mDb;
@Before
public void setUp() {
mContext = RuntimeEnvironment.application;
mManager = spy(new SlicesIndexer(mContext));
- mDb = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
}
@After
// Attempt indexing - should not do anything.
mManager.run();
- Cursor cursor = mDb.rawQuery("SELECT * FROM slices_index", null);
- cursor.moveToFirst();
- assertThat(cursor.getCount()).isEqualTo(1);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.KEY))).isEqualTo(newKey);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.TITLE))).isEqualTo(newTitle);
+ final SQLiteDatabase db = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
+ try (final Cursor cursor = db.rawQuery("SELECT * FROM slices_index", null)) {
+ cursor.moveToFirst();
+ assertThat(cursor.getCount()).isEqualTo(1);
+ assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.KEY))).isEqualTo(newKey);
+ assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.TITLE)))
+ .isEqualTo(newTitle);
+ } finally {
+ db.close();
+ }
}
@Test
mManager.run();
- final Cursor cursor = mDb.rawQuery("SELECT * FROM slices_index", null);
- assertThat(cursor.getCount()).isEqualTo(sliceData.size());
-
- cursor.moveToFirst();
- for (int i = 0; i < sliceData.size(); i++) {
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.KEY))).isEqualTo(
- KEYS[i]);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.TITLE))).isEqualTo(
- TITLES[i]);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.FRAGMENT))).isEqualTo(
- FRAGMENT_NAME);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.SCREENTITLE))).isEqualTo(
- SCREEN_TITLE);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.KEYWORDS))).isEqualTo(
- KEYWORDS);
- assertThat(cursor.getInt(cursor.getColumnIndex(IndexColumns.ICON_RESOURCE))).isEqualTo(
- ICON);
- assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.CONTROLLER))).isEqualTo(
- PREF_CONTROLLER);
- assertThat(cursor.getInt(cursor.getColumnIndex(IndexColumns.PLATFORM_SLICE))).isEqualTo(
- 1 /* true */);
- assertThat(cursor.getInt(cursor.getColumnIndex(IndexColumns.SLICE_TYPE))).isEqualTo(
- SLICE_TYPE);
- assertThat(cursor.getInt(
- cursor.getColumnIndex(IndexColumns.ALLOW_DYNAMIC_SUMMARY_IN_SLICE))).isEqualTo(
- 1 /* true */);
- cursor.moveToNext();
+ final SQLiteDatabase db = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
+ try (final Cursor cursor = db.rawQuery("SELECT * FROM slices_index", null)) {
+ assertThat(cursor.getCount()).isEqualTo(sliceData.size());
+
+ cursor.moveToFirst();
+ for (int i = 0; i < sliceData.size(); i++) {
+ assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.KEY)))
+ .isEqualTo(KEYS[i]);
+ assertThat(cursor.getString(cursor.getColumnIndex(IndexColumns.TITLE)))
+ .isEqualTo(TITLES[i]);
+ assertThat(
+ cursor.getString(cursor.getColumnIndex(IndexColumns.FRAGMENT)))
+ .isEqualTo(FRAGMENT_NAME);
+ assertThat(cursor.getString(
+ cursor.getColumnIndex(IndexColumns.SCREENTITLE))).isEqualTo(SCREEN_TITLE);
+ assertThat(
+ cursor.getString(cursor.getColumnIndex(IndexColumns.KEYWORDS)))
+ .isEqualTo(KEYWORDS);
+ assertThat(
+ cursor.getInt(cursor.getColumnIndex(IndexColumns.ICON_RESOURCE)))
+ .isEqualTo(ICON);
+ assertThat(
+ cursor.getString(cursor.getColumnIndex(IndexColumns.CONTROLLER)))
+ .isEqualTo(PREF_CONTROLLER);
+ assertThat(cursor.getInt(
+ cursor.getColumnIndex(IndexColumns.PLATFORM_SLICE)))
+ .isEqualTo(1 /* true */);
+ assertThat(cursor.getInt(cursor.getColumnIndex(IndexColumns.SLICE_TYPE)))
+ .isEqualTo(SLICE_TYPE);
+ assertThat(cursor.getInt(
+ cursor.getColumnIndex(
+ IndexColumns.ALLOW_DYNAMIC_SUMMARY_IN_SLICE)))
+ .isEqualTo(1 /* true */);
+ cursor.moveToNext();
+ }
+ } finally {
+ db.close();
}
}
final ContentValues values = new ContentValues();
values.put(IndexColumns.KEY, key);
values.put(IndexColumns.TITLE, title);
-
- mDb.replaceOrThrow(SlicesDatabaseHelper.Tables.TABLE_SLICES_INDEX, null, values);
+ final SQLiteDatabase db = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase();
+ db.beginTransaction();
+ try {
+ db.replaceOrThrow(SlicesDatabaseHelper.Tables.TABLE_SLICES_INDEX, null, values);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ db.close();
}
private List<SliceData> getDummyIndexableData() {
@After
public void tearDown() {
mShadowAudioManager.reset();
- mShadowMediaRouter.reset();
ShadowBluetoothUtils.reset();
}
@After
public void tearDown() {
mShadowAudioManager.reset();
- mShadowMediaRouter.reset();
ShadowBluetoothUtils.reset();
}
@After
public void tearDown() {
mShadowAudioManager.reset();
- mShadowMediaRouter.reset();
ShadowBluetoothUtils.reset();
}
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
-import android.os.UserManager;
import android.provider.Settings;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.testutils.shadow.ShadowUtils;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.Shadows;
-import org.robolectric.shadows.ShadowUserManager;
+import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = ShadowUserManager.class)
public class FactoryResetPreferenceControllerTest {
private static final String FACTORY_RESET_KEY = "factory_reset";
@Before
public void setUp() {
mContext = RuntimeEnvironment.application;
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- mShadowUserManager = Shadows.shadowOf(userManager);
+ mShadowUserManager = ShadowUserManager.getShadow();
mController = new FactoryResetPreferenceController(mContext);
}
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.XmlTestUtils;
import com.android.settings.testutils.shadow.SettingsShadowResources;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import org.junit.After;
import org.junit.Before;
import java.util.List;
@RunWith(SettingsRobolectricTestRunner.class)
-@Config(shadows = SettingsShadowResources.class)
+@Config(shadows = {SettingsShadowResources.class, ShadowUserManager.class})
public class SystemDashboardFragmentTest {
@Before
public void setup() {
SettingsShadowResources.overrideResource(
com.android.internal.R.bool.config_supportSystemNavigationKeys, true);
+ ShadowUserManager.getShadow().setIsAdminUser(true);
}
@After
public void tearDown() {
SettingsShadowResources.reset();
+ ShadowUserManager.getShadow().reset();
}
@Test
import android.os.Build;
import android.os.Bundle;
import android.os.SystemUpdateManager;
-import android.os.UserManager;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.ShadowUserManager;
import org.junit.After;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
-import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
-import org.robolectric.shadows.ShadowUserManager;
import java.util.ArrayList;
import java.util.List;
@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = ShadowUserManager.class)
public class SystemUpdatePreferenceControllerTest {
@Mock
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
- UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
- mShadowUserManager = Shadows.shadowOf(userManager);
+ mShadowUserManager = ShadowUserManager.getShadow();
ShadowApplication.getInstance().setSystemService(Context.SYSTEM_UPDATE_SERVICE,
mSystemUpdateManager);
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.android_version_summary, Build.VERSION.RELEASE));
+ .isEqualTo(mContext.getString(R.string.android_version_summary,
+ Build.VERSION.RELEASE));
}
@Test
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.android_version_summary, testReleaseName));
+ .isEqualTo(mContext.getString(R.string.android_version_summary, testReleaseName));
}
@Test
mController.updateState(mPreference);
assertThat(mPreference.getSummary())
- .isEqualTo(mContext.getString(R.string.android_version_pending_update_summary));
+ .isEqualTo(mContext.getString(R.string.android_version_pending_update_summary));
}
}
\ No newline at end of file
+++ /dev/null
-/*
- * 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.testutils;
-
-import static com.google.common.truth.Truth.assertAbout;
-
-import static org.robolectric.RuntimeEnvironment.application;
-
-import androidx.annotation.Nullable;
-
-import com.google.common.truth.ComparableSubject;
-import com.google.common.truth.FailureStrategy;
-import com.google.common.truth.SubjectFactory;
-
-/**
- * Custom subject for use with {@link com.google.common.truth.Truth}, to provide a more readable
- * error message, so that instead of "Not true that 2130706432 equals to 17170444", it will say
- * "Not true that color/my_color equals to android:color/black".
- *
- * <p>Usage:
- * <pre>{@code
- * ResIdSubject.assertResId(activity.getThemeResId()).isEqualTo(android.R.style.Theme_Material)
- * }</pre>
- */
-public class ResIdSubject extends ComparableSubject<ResIdSubject, Integer> {
-
- public static final SubjectFactory<ResIdSubject, Integer> FACTORY =
- new SubjectFactory<ResIdSubject, Integer>() {
- @Override
- public ResIdSubject getSubject(
- FailureStrategy failureStrategy, Integer integer) {
- return new ResIdSubject(failureStrategy, integer);
- }
- };
-
- public static ResIdSubject assertResId(int resId) {
- return assertAbout(ResIdSubject.FACTORY).that(resId);
- }
-
- public ResIdSubject(
- FailureStrategy failureStrategy,
- @Nullable Integer integer) {
- super(failureStrategy, integer);
- }
-
- public void isEqualTo(int other) {
- Integer subject = getSubject();
- if (subject == null || subject != other) {
- fail("equals to", resIdToString(other));
- }
- }
-
- @Override
- protected String getDisplaySubject() {
- String resourceName = "<" + resIdToString(getSubject()) + ">";
- String customName = internalCustomName();
- if (customName != null) {
- return customName + " " + resourceName;
- } else {
- return resourceName;
- }
- }
-
- private static String resIdToString(int resId) {
- return application.getResources().getResourceName(resId);
- }
-}
paths.add(new ResourcePath(null,
Fs.fromURL(new URL("file:frameworks/opt/setupwizard/library/main/res")), null));
paths.add(new ResourcePath(null,
+ Fs.fromURL(new URL("file:out/target/common/obj/JAVA_LIBRARIES/robolectric_android-all-stub_intermediates/classes/raw-res/res")), null));
+ paths.add(new ResourcePath(null,
Fs.fromURL(new URL("file:frameworks/opt/setupwizard/library/gingerbread/res")), null));
paths.add(new ResourcePath(null,
Fs.fromURL(new URL("file:frameworks/opt/setupwizard/library/recyclerview/res")), null));
import com.android.settings.R;
-import org.robolectric.RuntimeEnvironment;
-import org.robolectric.Shadows;
import org.robolectric.android.XmlResourceParserImpl;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.annotation.RealObject;
-import org.robolectric.shadows.ShadowAssetManager;
import org.robolectric.shadows.ShadowResources;
import org.robolectric.util.ReflectionHelpers;
import org.robolectric.util.ReflectionHelpers.ClassParameter;
* Shadow Resources and Theme classes to handle resource references that Robolectric shadows cannot
* handle because they are too new or private.
*/
-@Implements(value = Resources.class, inheritImplementationMethods = true)
+@Implements(value = Resources.class)
public class SettingsShadowResources extends ShadowResources {
@RealObject
ClassParameter.from(int.class, id));
}
- @Implements(value = Theme.class, inheritImplementationMethods = true)
- public static class SettingsShadowTheme extends ShadowTheme {
+ @Implements(value = Theme.class)
+ public static class SettingsShadowTheme extends ShadowLegacyTheme {
@RealObject
Theme realTheme;
- private ShadowAssetManager mAssetManager = Shadows.shadowOf(
- RuntimeEnvironment.application.getAssets());
-
@Implementation
- public TypedArray obtainStyledAttributes(
+ protected TypedArray obtainStyledAttributes(
AttributeSet set, int[] attrs, int defStyleAttr, int defStyleRes) {
// Replace all private string references with a placeholder.
if (set != null) {
}
private Resources getResources() {
- return ReflectionHelpers.callInstanceMethod(ShadowTheme.class, this, "getResources");
+ return ReflectionHelpers.callInstanceMethod(ShadowLegacyTheme.class, this, "getResources");
}
}
}
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
-import org.robolectric.shadows.ShadowResourcesImpl;
+import org.robolectric.shadows.ShadowLegacyResourcesImpl;
@Implements(
value = ResourcesImpl.class,
- inheritImplementationMethods = true,
isInAndroidSdk = false,
minSdk = 26
)
-public class SettingsShadowResourcesImpl extends ShadowResourcesImpl {
+public class SettingsShadowResourcesImpl extends ShadowLegacyResourcesImpl {
@Implementation
public Drawable loadDrawable(Resources wrapper, TypedValue value, int id, int density,
import org.robolectric.annotation.RealObject;
import org.robolectric.shadows.ShadowTypedArray;
-@Implements(value = TypedArray.class, inheritImplementationMethods = true)
+@Implements(value = TypedArray.class)
public class SettingsShadowTypedArray extends ShadowTypedArray {
@RealObject
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
-import org.robolectric.shadows.ShadowApplication;
@Implements(CustomActivity.class)
public class ShadowActivity extends org.robolectric.shadows.ShadowActivity {
@Implementation
- public void startActivityAsUser(Intent intent, UserHandle user) {
- ShadowApplication.getInstance().startActivity(intent);
+ protected void startActivityAsUser(Intent intent, UserHandle user) {
+ realActivity.startActivity(intent);
}
}
import java.util.ArrayList;
-@Implements(value = AudioManager.class, inheritImplementationMethods = true)
+@Implements(value = AudioManager.class)
public class ShadowAudioManager extends org.robolectric.shadows.ShadowAudioManager {
private int mRingerMode;
private int mDeviceCodes;
import java.util.ArrayList;
import java.util.List;
-@Implements(value = BluetoothAdapter.class, inheritImplementationMethods = true)
+@Implements(value = BluetoothAdapter.class)
public class ShadowBluetoothAdapter extends org.robolectric.shadows.ShadowBluetoothAdapter {
- private String mName;
- private int mScanMode;
private int mState;
private List<Integer> mSupportedProfiles = new ArrayList<Integer>();
mSupportedProfiles.clear();
}
- public void setName(String name) {
- mName = name;
- }
-
- @Implementation
- public String getName() {
- return mName;
- }
-
- @Implementation
- public void setScanMode(int scanMode) {
- mScanMode = scanMode;
- }
-
- @Implementation
- public int getScanMode() {
- return mScanMode;
- }
-
@Implementation
public int getConnectionState() {
return mState;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
-@Implements(value = BluetoothDevice.class, inheritImplementationMethods = true)
+@Implements(value = BluetoothDevice.class)
public class ShadowBluetoothDevice extends org.robolectric.shadows.ShadowBluetoothDevice {
private int mMessageAccessPermission = BluetoothDevice.ACCESS_UNKNOWN;
+++ /dev/null
-/*
- * 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.testutils.shadow;
-
-import android.content.Context;
-import android.util.AttributeSet;
-
-import androidx.cardview.widget.CardView;
-
-import org.robolectric.annotation.Implements;
-import org.robolectric.shadows.ShadowFrameLayout;
-
-/**
- * Shadow for CardView to get around view not implemented error.
- */
-@Implements(CardView.class)
-public class ShadowCardView extends ShadowFrameLayout {
-
- public void __constructor__(Context context, AttributeSet attrs, int defStyleAttr) {
- // do nothing
- }
-
-}
import org.robolectric.annotation.Implements;
import org.robolectric.shadow.api.Shadow;
-@Implements(value = ConnectivityManager.class, inheritImplementationMethods = true)
+@Implements(value = ConnectivityManager.class)
public class ShadowConnectivityManager extends org.robolectric.shadows.ShadowConnectivityManager {
private final SparseBooleanArray mSupportedNetworkTypes = new SparseBooleanArray();
package com.android.settings.testutils.shadow;
-import android.content.Context;
import android.hardware.fingerprint.Fingerprint;
import android.hardware.fingerprint.FingerprintManager;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
-import org.robolectric.annotation.Resetter;
import org.robolectric.shadow.api.Shadow;
-import org.robolectric.shadows.ShadowContextImpl;
-import org.robolectric.util.ReflectionHelpers;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
import java.util.stream.IntStream;
@Implements(FingerprintManager.class)
-public class ShadowFingerprintManager {
+public class ShadowFingerprintManager extends org.robolectric.shadows.ShadowFingerprintManager {
- private static Map<String, String> getSystemServiceMap() {
- return ReflectionHelpers.getStaticField(ShadowContextImpl.class, "SYSTEM_SERVICE_MAP");
- }
-
- /**
- * Call this in @Before of a test to add FingerprintManager to Robolectric's system service
- * map. Otherwise getSystemService(FINGERPRINT_SERVICE) will return null.
- */
- public static void addToServiceMap() {
- getSystemServiceMap().put(Context.FINGERPRINT_SERVICE, FingerprintManager.class.getName());
- }
-
- @Resetter
- public static void reset() {
- getSystemServiceMap().remove(Context.FINGERPRINT_SERVICE);
- }
public boolean hardwareDetected = true;
private List<Fingerprint> mFingerprints = Collections.emptyList();
@Implementation
- public boolean isHardwareDetected() {
+ protected boolean isHardwareDetected() {
return hardwareDetected;
}
@Implementation
- public boolean hasEnrolledFingerprints() {
+ protected boolean hasEnrolledFingerprints() {
return !mFingerprints.isEmpty();
}
@Implementation
- public List<Fingerprint> getEnrolledFingerprints() {
+ protected List<Fingerprint> getEnrolledFingerprints() {
return mFingerprints;
}
@Implementation
- public List<Fingerprint> getEnrolledFingerprints(int userId) {
+ protected List<Fingerprint> getEnrolledFingerprints(int userId) {
return mFingerprints;
}
import android.media.MediaRouter;
import org.robolectric.annotation.Implements;
-import org.robolectric.annotation.Resetter;
import org.robolectric.shadow.api.Shadow;
import java.util.concurrent.CopyOnWriteArrayList;
-@Implements(value = MediaRouter.class, inheritImplementationMethods = true)
+@Implements(value = MediaRouter.class)
public class ShadowMediaRouter extends org.robolectric.shadows.ShadowMediaRouter {
MediaRouter.RouteInfo mSelectedRoute;
}
public void removeCallback(MediaRouter.Callback cb) {
- if (mCallbacks.contains(cb))
+ if (mCallbacks.contains(cb)) {
mCallbacks.remove(cb);
+ }
}
public static ShadowMediaRouter getShadow() {
return Shadow.extract(application.getSystemService(MediaRouter.class));
}
-
- @Resetter
- public void reset() {
- mCallbacks.clear();
- }
}
import java.util.Map;
import java.util.Set;
-@Implements(value = UserManager.class, inheritImplementationMethods = true)
+@Implements(value = UserManager.class)
public class ShadowUserManager extends org.robolectric.shadows.ShadowUserManager {
private SparseArray<UserInfo> mUserInfos = new SparseArray<>();
private final List<UserInfo> mUserProfileInfos = new ArrayList<>();
private final Set<Integer> mManagedProfiles = new HashSet<>();
private boolean mIsQuietModeEnabled = false;
- private int[] profileIdsForUser;
+ private int[] profileIdsForUser = new int[0];
private boolean mUserSwitchEnabled;
mManagedProfiles.clear();
mIsQuietModeEnabled = false;
mUserSwitchEnabled = false;
+ profileIdsForUser = new int[0];
}
public void setUserInfo(int userHandle, UserInfo userInfo) {
}
@Implementation
- public UserInfo getUserInfo(int userHandle) {
+ protected UserInfo getUserInfo(int userHandle) {
return mUserInfos.get(userHandle);
}
}
@Implementation
- public List<UserInfo> getProfiles(@UserIdInt int userHandle) {
+ protected List<UserInfo> getProfiles(@UserIdInt int userHandle) {
return mUserProfileInfos;
}
@Implementation
- public int[] getProfileIds(@UserIdInt int userHandle, boolean enabledOnly) {
+ protected int[] getProfileIds(@UserIdInt int userHandle, boolean enabledOnly) {
int[] ids = new int[mUserProfileInfos.size()];
for (int i = 0; i < mUserProfileInfos.size(); i++) {
ids[i] = mUserProfileInfos.get(i).id;
}
@Implementation
- public int getCredentialOwnerProfile(@UserIdInt int userHandle) {
+ protected int getCredentialOwnerProfile(@UserIdInt int userHandle) {
return userHandle;
}
@Implementation
- public boolean hasBaseUserRestriction(String restrictionKey, UserHandle userHandle) {
+ protected boolean hasBaseUserRestriction(String restrictionKey, UserHandle userHandle) {
return mRestrictions.contains(restrictionKey);
}
}
@Implementation
- public List<EnforcingUser> getUserRestrictionSources(
+ protected List<EnforcingUser> getUserRestrictionSources(
String restrictionKey, UserHandle userHandle) {
// Return empty list when there is no enforcing user, otherwise might trigger
// NullPointer Exception in RestrictedLockUtils.checkIfRestrictionEnforced.
}
@Implementation
- public boolean isManagedProfile(@UserIdInt int userId) {
+ protected boolean isManagedProfile(@UserIdInt int userId) {
return mManagedProfiles.contains(userId);
}
}
@Implementation
- public boolean isQuietModeEnabled(UserHandle userHandle) {
+ protected boolean isQuietModeEnabled(UserHandle userHandle) {
return mIsQuietModeEnabled;
}
}
@Implementation
- public int[] getProfileIdsWithDisabled(@UserIdInt int userId) {
+ protected int[] getProfileIdsWithDisabled(@UserIdInt int userId) {
return profileIdsForUser;
}
}
@Implementation
- public boolean isUserSwitcherEnabled() {
+ protected boolean isUserSwitcherEnabled() {
return mUserSwitchEnabled;
}
+++ /dev/null
-/*
- * 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.testutils.shadow;
-
-import static org.mockito.Mockito.mock;
-
-import android.content.Context;
-import android.media.AudioAttributes;
-import android.os.SystemVibrator;
-import android.os.VibrationEffect;
-import android.os.Vibrator;
-
-import org.robolectric.annotation.Implementation;
-import org.robolectric.annotation.Implements;
-import org.robolectric.fakes.RoboVibrator;
-import org.robolectric.shadows.ShadowContextImpl;
-import org.robolectric.util.ReflectionHelpers;
-
-import java.util.Map;
-
-@Implements(SystemVibrator.class)
-public class ShadowVibrator {
-
- private static Map<String, String> getSystemServiceMap() {
- return ReflectionHelpers.getStaticField(ShadowContextImpl.class, "SYSTEM_SERVICE_MAP");
- }
-
- public static void addToServiceMap() {
- getSystemServiceMap().put(Context.VIBRATOR_SERVICE, SystemVibrator.class.getName());
- }
-
- public static void reset() {
- getSystemServiceMap().put(Context.VIBRATOR_SERVICE, RoboVibrator.class.getName());
- }
-
- public final Vibrator delegate = mock(Vibrator.class);
-
- @Implementation
- public void vibrate(int uid, String opPkg, VibrationEffect vibe, String reason,
- AudioAttributes attributes) {
- delegate.vibrate(uid, opPkg, vibe, reason, attributes);
- }
-}
import java.util.Collections;
import java.util.List;
-@Implements(value = WifiManager.class, inheritImplementationMethods = true)
+@Implements(value = WifiManager.class)
public class ShadowWifiManager extends org.robolectric.shadows.ShadowWifiManager {
public WifiConfiguration savedWifiConfig;
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;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- ShadowApplication shadowContext = ShadowApplication.getInstance();
+ mContext = RuntimeEnvironment.application;
mUserManager = ShadowUserManager.getShadow();
- mContext = shadowContext.getApplicationContext();
mController = new AddUserWhenLockedPreferenceController(mContext, "fake_key");
}
MockitoAnnotations.initMocks(this);
ShadowApplication shadowContext = ShadowApplication.getInstance();
shadowContext.setSystemService(Context.USER_SERVICE, mUserManager);
- mContext = shadowContext.getApplicationContext();
+ mContext = RuntimeEnvironment.application;
mController = new AutoSyncDataPreferenceController(mContext, mFragment);
mConfirmSyncFragment = new AutoSyncDataPreferenceController.ConfirmAutoSyncChangeFragment();
mConfirmSyncFragment.setTargetFragment(mFragment, 0);
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import java.util.ArrayList;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
+ mContext = RuntimeEnvironment.application;
ShadowApplication shadowContext = ShadowApplication.getInstance();
shadowContext.setSystemService(Context.USER_SERVICE, mUserManager);
- mContext = shadowContext.getApplicationContext();
mController = new AutoSyncPersonalDataPreferenceController(mContext, mFragment);
mPreference = new Preference(mContext);
mPreference.setKey(mController.getPreferenceKey());
import static com.google.common.truth.Truth.assertThat;
+import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Robolectric;
@RunWith(SettingsRobolectricTestRunner.class)
public class WallpaperTypePreferenceControllerTest {
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mContext = RuntimeEnvironment.application;
+ mContext = Robolectric.setupActivity(Activity.class);
mController = new WallpaperTypePreferenceController(mContext, "pref_key");
mIntent = new Intent();
mPreference = new Preference(mContext);
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.drawer.CategoryKey;
import com.android.settingslib.drawer.Tile;
+import com.android.settingslib.testutils.DrawableTestHelper;
import org.junit.Before;
import org.junit.Test;
new RoundedHomepageIcon(mContext, new ColorDrawable(Color.BLACK));
assertThat(icon.getNumberOfLayers()).isEqualTo(2);
- assertThat(icon.getDrawable(0))
- .isEqualTo(mContext.getDrawable(R.drawable.ic_homepage_generic_background));
+ DrawableTestHelper.assertDrawableResId(icon.getDrawable(0),
+ R.drawable.ic_homepage_generic_background);
}
@Test
assertThat(((TextView) mBar.findViewById(R.id.switch_text)).getText())
.isEqualTo(mContext.getString(defaultOffText));
- assertThat(mBar.getBackground()).isEqualTo(new ColorDrawable(COLOR_BACKGROUND));
mBar.setChecked(true);
- assertThat(mBar.getBackground()).isEqualTo(new ColorDrawable(COLOR_BACKGROUND_ACTIVATED));
+ assertThat(mBar.getBackground()).isInstanceOf(ColorDrawable.class);
assertThat(((TextView) mBar.findViewById(R.id.switch_text)).getText())
.isEqualTo(mContext.getString(defaultOnText));
}
final int offText = R.string.manage_space_text;
mBar.setSwitchBarText(onText, offText);
- assertThat(mBar.getBackground()).isEqualTo(new ColorDrawable(COLOR_BACKGROUND));
assertThat(((TextView) mBar.findViewById(R.id.switch_text)).getText())
.isEqualTo(mContext.getString(offText));
mBar.setChecked(true);
- assertThat(mBar.getBackground()).isEqualTo(new ColorDrawable(COLOR_BACKGROUND_ACTIVATED));
+ assertThat(mBar.getBackground()).isInstanceOf(ColorDrawable.class);
+
assertThat(((TextView) mBar.findViewById(R.id.switch_text)).getText())
.isEqualTo(mContext.getString(onText));
}
@Test
public void updateState_preferenceSetCheckedWhenSettingsAreEnabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1);
mController.updateState(preference);
@Test
public void updateState_preferenceSetCheckedWhenSettingsAreDisabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(),
+ Settings.Global.putInt(mContext.getContentResolver(),
WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0);
mController.updateState(preference);
@RunWith(SettingsRobolectricTestRunner.class)
public class WifiWakeupPreferenceControllerTest {
- private static final String NO_LOCATION_STRING =
- "Unavailable because location is turned off. Turn on location.";
private Context mContext;
private WifiWakeupPreferenceController mController;
@Mock
- DashboardFragment mFragment;
+ private DashboardFragment mFragment;
@Mock
- LocationManager mLocationManager;
+ private LocationManager mLocationManager;
@Mock
- SwitchPreference mPreference;
+ private SwitchPreference mPreference;
@Before
public void setUp() {
mController.mLocationManager = mLocationManager;
mController.mPreference = mPreference;
- Settings.System.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 1);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 1);
doReturn(true).when(mLocationManager).isLocationEnabled();
}
@Test
public void updateState_preferenceSetCheckedWhenWakeupSettingEnabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 1);
mController.updateState(preference);
@Test
public void updateState_preferenceSetUncheckedWhenWakeupSettingDisabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 0);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 0);
mController.updateState(preference);
@Test
public void updateState_preferenceSetUncheckedWhenWifiScanningDisabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 0);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 0);
mController.updateState(preference);
@Test
public void updateState_preferenceSetUncheckedWhenWakeupSettingEnabledNoLocation() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
doReturn(false).when(mLocationManager).isLocationEnabled();
mController.updateState(preference);
@Test
public void updateState_preferenceSetUncheckedWhenWakeupSettingDisabledLocationEnabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 0);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 0);
doReturn(false).when(mLocationManager).isLocationEnabled();
mController.updateState(preference);
@Test
public void updateState_preferenceSetUncheckedWhenWifiScanningDisabledLocationEnabled() {
final SwitchPreference preference = mock(SwitchPreference.class);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
- Settings.System.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 0);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
+ Settings.Global.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 0);
doReturn(false).when(mLocationManager).isLocationEnabled();
mController.updateState(preference);
OSDN Git Service
