com.android.settings.RestrictedListPreference$RestrictedListPreferenceDialogFragment
com.android.settings.password.ConfirmDeviceCredentialBaseFragment$LastTryDialog
com.android.settings.password.CredentialCheckResultTracker
+com.android.settings.localepicker.LocalePickerWithRegion
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowActivity;
final Intent intent = new Intent().setClassName(
RuntimeEnvironment.application.getPackageName(), HelpTrampoline.class.getName())
.putExtra(Intent.EXTRA_TEXT, "help_url_upgrading");
- final ShadowActivity shadow =
- shadowOf(Robolectric.buildActivity(HelpTrampoline.class, intent).create().get());
+ final ShadowActivity shadow = Shadows.
+ shadowOf(Robolectric.buildActivity(HelpTrampoline.class, intent).create().get());
final Intent launchedIntent = shadow.getNextStartedActivity();
assertThat(ShadowHelpUtils.isGetHelpIntentCalled()).isTrue();
package com.android.settings;
import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import android.widget.LinearLayout;
import android.widget.ScrollView;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowUtils;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.Robolectric;
+import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowActivity;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = ShadowUtils.class)
public class MasterClearTest {
private AccountManager mAccountManager;
@Mock
- private Activity mMockActivity;
+ private FragmentActivity mMockActivity;
@Mock
private Intent mMockIntent;
private MasterClear mMasterClear;
private ShadowActivity mShadowActivity;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private View mContentView;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mMasterClear = spy(new MasterClear());
- mActivity = Robolectric.setupActivity(Activity.class);
- mShadowActivity = shadowOf(mActivity);
+ mActivity = Robolectric.setupActivity(FragmentActivity.class);
+ mShadowActivity = Shadows.shadowOf(mActivity);
mContentView = LayoutInflater.from(mActivity).inflate(R.layout.master_clear, null);
// Make scrollView only have one child
// 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 = shadowOf(application).getNextStartedActivity();
+ Intent started = Shadows.shadowOf(application).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 = shadowOf(application).getNextStartedActivity();
+ Intent started = Shadows.shadowOf(application).getNextStartedActivity();
Bundle extras = started.getExtras();
int reason = extras.getInt(EXTRA_UNLAUNCHABLE_REASON);
assertThat(reason).isEqualTo(UNLAUNCHABLE_REASON_QUIET_MODE);
@Test
public void launchSettingFragment_nullExtraShowFragment_shouldNotCrash() {
- when(mActivity.getFragmentManager()).thenReturn(mFragmentManager);
+ when(mActivity.getSupportFragmentManager()).thenReturn(mFragmentManager);
when(mFragmentManager.beginTransaction()).thenReturn(mock(FragmentTransaction.class));
doReturn(RuntimeEnvironment.application.getClassLoader()).when(mActivity).getClassLoader();
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.android.controller.ActivityController;
import java.io.File;
intent.addCategory(Intent.CATEGORY_DEFAULT);
intent.setPackage("com.android.htmlviewer");
- assertEqualIntents(shadowOf(mApplication).getNextStartedActivity(), intent);
+ assertEqualIntents(Shadows.shadowOf(mApplication).getNextStartedActivity(), intent);
}
@Test
+ @Ignore("b/111194177")
public void testOnCreateWithGeneratedHtmlFile() {
doReturn(null).when(mActivity).onCreateLoader(anyInt(), any());
doReturn(Uri.parse("content://com.android.settings.files/my_cache/generated_test.html"))
intent.addCategory(Intent.CATEGORY_DEFAULT);
intent.setPackage("com.android.htmlviewer");
- assertEqualIntents(shadowOf(mApplication).getNextStartedActivity(), intent);
+ assertEqualIntents(Shadows.shadowOf(mApplication).getNextStartedActivity(), intent);
}
}
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceManager;
private static final int ITEM_COUNT = 5;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private View mListContainer;
@Mock
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
import com.android.settings.widget.SwitchBar;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
-import org.robolectric.util.FragmentTestUtil;
import androidx.annotation.XmlRes;
@Test
public void createFragment_shouldOnlyAddPreferencesOnce() {
mFragment = spy(new ToggleFeaturePreferenceFragmentTestable());
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
// execute exactly once
verify(mFragment).addPreferencesFromResource(R.xml.placeholder_prefs);
extends ToggleFeaturePreferenceFragment {
@Override
- protected void onPreferenceToggled(String preferenceKey, boolean enabled) {}
+ protected void onPreferenceToggled(String preferenceKey, boolean enabled) {
+ }
@Override
public int getMetricsCategory() {
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import android.app.Activity;
import android.content.Context;
import android.os.UserHandle;
import android.provider.SearchIndexableResource;
import com.android.settings.R;
import com.android.settings.dashboard.SummaryLoader;
+import com.android.settings.testutils.Robolectric;
import com.android.settingslib.accounts.AuthenticatorHelper;
import com.android.settingslib.drawer.CategoryKey;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(RobolectricTestRunner.class)
public class AccountDashboardFragmentTest {
})
public void updateSummary_hasAccount_shouldDisplayUpTo3AccountTypes() {
final SummaryLoader loader = mock(SummaryLoader.class);
- final Activity activity = Robolectric.buildActivity(Activity.class).setup().get();
+ final FragmentActivity activity = Robolectric.buildActivity(
+ FragmentActivity.class).setup().get();
final SummaryLoader.SummaryProvider provider =
AccountDashboardFragment.SUMMARY_PROVIDER_FACTORY.createSummaryProvider(activity,
public void updateSummary_noAccount_shouldDisplayDefaultSummary() {
ShadowAuthenticationHelper.setEnabledAccount(null);
final SummaryLoader loader = mock(SummaryLoader.class);
- final Activity activity = Robolectric.buildActivity(Activity.class).setup().get();
+ final FragmentActivity activity = Robolectric.buildActivity(FragmentActivity.class).setup().get();
final SummaryLoader.SummaryProvider provider =
AccountDashboardFragment.SUMMARY_PROVIDER_FACTORY.createSummaryProvider(activity,
@Config(shadows = ShadowAuthenticationHelper.class)
public void updateSummary_noAccountTypeLabel_shouldNotDisplayNullEntry() {
final SummaryLoader loader = mock(SummaryLoader.class);
- final Activity activity = Robolectric.buildActivity(Activity.class).setup().get();
+ final FragmentActivity activity = Robolectric.buildActivity(FragmentActivity.class).setup().get();
final String[] enabledAccounts = {TYPES[0], "unlabeled_account_type", TYPES[1]};
ShadowAuthenticationHelper.setEnabledAccount(enabledAccounts);
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.util.ReflectionHelpers;
import androidx.preference.Preference;
preference.performClick();
- final Intent intent = shadowOf(activity).getNextStartedActivityForResult().intent;
+ final Intent intent = Shadows.shadowOf(activity).getNextStartedActivityForResult().intent;
assertThat(intent.getStringExtra("extra.accountName")).isEqualTo("name1@abc.com");
}
import org.robolectric.annotation.Implements;
import androidx.lifecycle.LifecycleOwner;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceScreen;
@RunWith(SettingsRobolectricTestRunner.class)
@Mock
private Activity mActivity;
@Mock
- private PreferenceFragment mFragment;
+ private PreferenceFragmentCompat mFragment;
@Mock
private PreferenceScreen mScreen;
import static org.mockito.Mockito.when;
import android.accounts.Account;
-import android.app.Activity;
import android.content.Context;
import android.os.UserHandle;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {ShadowContentResolver.class})
public class AccountSyncSettingsTest {
public void onPreferenceTreeClick_nullAuthority_shouldNotCrash() {
final Context context = RuntimeEnvironment.application;
final AccountSyncSettings settings = spy(new AccountSyncSettings());
- when(settings.getActivity()).thenReturn(mock(Activity.class));
+ when(settings.getActivity()).thenReturn(mock(FragmentActivity.class));
final SyncStateSwitchPreference preference = new SyncStateSwitchPreference(context,
new Account("acct1", "type1"), "" /* authority */, "testPackage", 1 /* uid */);
preference.setOneTimeSyncMode(false);
import org.robolectric.shadows.ShadowApplication;
import androidx.preference.Preference;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceGroup;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock(answer = RETURNS_DEEP_STUBS)
private AccountManager mAccountManager;
@Mock(answer = RETURNS_DEEP_STUBS)
- private PreferenceFragment mPreferenceFragment;
+ private PreferenceFragmentCompat mPreferenceFragment;
@Mock
private PackageManager mPackageManager;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mController = spy(new ChooseAccountPreferenceController(mContext, "controller_key"));
- mActivity = Robolectric.setupActivity(Activity.class);
+ mActivity = Robolectric.setupActivity(FragmentActivity.class);
mPreferenceManager = new PreferenceManager(mContext);
mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext);
}
import com.android.settings.core.BasePreferenceController;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
-import com.android.settingslib.widget.FooterPreferenceMixin;
+import com.android.settingslib.widget.FooterPreferenceMixinCompat;
import org.junit.Before;
import org.junit.Test;
private ChooseAccountFragment mFragment;
private Context mContext;
private EnterpriseDisclosurePreferenceController mController;
- private FooterPreferenceMixin mFooterPreferenceMixin;
+ private FooterPreferenceMixinCompat mFooterPreferenceMixin;
private PreferenceManager mPreferenceManager;
private PreferenceScreen mPreferenceScreen;
mContext = RuntimeEnvironment.application;
mController = spy(new EnterpriseDisclosurePreferenceController(mContext));
mFragment = spy(new ChooseAccountFragment());
- mFooterPreferenceMixin = new FooterPreferenceMixin(mFragment, mFragment.getLifecycle());
+ mFooterPreferenceMixin = new FooterPreferenceMixinCompat(mFragment,
+ mFragment.getSettingsLifecycle());
mPreferenceManager = new PreferenceManager(mContext);
mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext);
}
import java.util.ArrayList;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock(answer = RETURNS_DEEP_STUBS)
private AccountManager mAccountManager;
@Mock
- private PreferenceFragment mFragment;
+ private PreferenceFragmentCompat mFragment;
@Mock
private PreferenceManager mPreferenceManager;
@Mock
@Config(shadows = {ShadowAccountManager.class, ShadowContentResolver.class})
public void confirmRemove_shouldRemoveAccount() {
when(mFragment.isAdded()).thenReturn(true);
- Activity activity = mock(Activity.class);
+ FragmentActivity activity = mock(FragmentActivity.class);
when(activity.getSystemService(Context.ACCOUNT_SERVICE)).thenReturn(mAccountManager);
when(mFragment.getActivity()).thenReturn(activity);
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import android.app.ActionBar;
-import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.PreferenceScreen;
private LayoutPreference mPreference;
private Context mContext;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private LifecycleOwner mLifecycleOwner;
private Lifecycle mLifecycle;
private View mHeader;
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
- mActivity = spy(Robolectric.buildActivity(Activity.class).get());
+ mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get());
mLifecycleOwner = () -> mLifecycle;
mLifecycle = new Lifecycle(mLifecycleOwner);
mHeader = LayoutInflater.from(mContext).inflate(R.layout.settings_entity_header, null);
final Context context = mock(Context.class);
doReturn(context).when(mFragment).getContext();
ReflectionHelpers.setField(mFragment, "mLifecycle", mock(Lifecycle.class));
- ReflectionHelpers.setField(mFragment, "mCheckedForLoaderManager", true);
mFragment.startListeningToPackageRemove();
mFragment.onDestroy();
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.app.usage.IUsageStatsManager;
import android.content.Context;
import android.content.Intent;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
@Test
public void getArguments_containsChannelId() {
- Activity activity = mock(Activity.class);
+ FragmentActivity activity = mock(FragmentActivity.class);
Intent intent = new Intent();
intent.putExtra(EXTRA_FRAGMENT_ARG_KEY, "test");
when(mFragment.getActivity()).thenReturn(activity);
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowPackageManager;
import androidx.preference.Preference;
public void setUp() {
MockitoAnnotations.initMocks(this);
mApplication = RuntimeEnvironment.application;
- mPackageManager = shadowOf(mApplication.getPackageManager());
+ mPackageManager = Shadows.shadowOf(mApplication.getPackageManager());
mController = new AppSettingPreferenceController(mApplication, "test_key");
mController.setPackageName(TEST_PKG_NAME).setParentFragment(mParent);
mPreference = new Preference(mApplication);
mPackageManager.addResolveInfoForIntent(RESOLVED_INTENT, info);
assertThat(mController.handlePreferenceTreeClick(mPreference)).isTrue();
- assertThat(shadowOf(mApplication).getNextStartedActivity().getComponent())
+ assertThat(Shadows.shadowOf(mApplication).getNextStartedActivity().getComponent())
.isEqualTo(TEST_INTENT.getComponent());
}
}
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowAlertDialog;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
import androidx.fragment.app.Fragment;
public void testOnCreateDialog_forceStopDialog() {
ButtonActionDialogFragment fragment = ButtonActionDialogFragment.newInstance(FORCE_STOP_ID);
- FragmentTestUtil.startFragment(fragment);
+ FragmentTestUtils.startFragment(fragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mShadowContext.getString(R.string.force_stop_dlg_text));
public void testOnCreateDialog_disableDialog() {
ButtonActionDialogFragment fragment = ButtonActionDialogFragment.newInstance(DISABLE_ID);
- FragmentTestUtil.startFragment(fragment);
+ FragmentTestUtils.startFragment(fragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mShadowContext.getString(R.string.app_disable_dlg_text));
ButtonActionDialogFragment fragment =
ButtonActionDialogFragment.newInstance(SPECIAL_DISABLE_ID);
- FragmentTestUtil.startFragment(fragment);
+ FragmentTestUtils.startFragment(fragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mShadowContext.getString(R.string.app_disable_dlg_text));
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class DrawOverlayDetailsTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private Window mWindow;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowAlertDialog;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
@RunWith(SettingsRobolectricTestRunner.class)
public class InstantAppButtonDialogFragmentTest {
public void onClick_shouldDeleteApp() {
final PackageManager packageManager = mock(PackageManager.class);
when(mContext.getPackageManager()).thenReturn(packageManager);
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
mFragment.onClick(null /* dialog */, 0 /* which */);
@Test
public void onCreateDialog_clearAppDialog_shouldShowClearAppDataConfirmation() {
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- final ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ final ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.clear_instant_app_confirmation));
import java.util.ArrayList;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
@RunWith(SettingsRobolectricTestRunner.class)
public class DefaultAppPickerFragmentTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private PreferenceScreen mScreen;
@Mock
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Looper;
import java.util.ArrayList;
+import androidx.fragment.app.FragmentActivity;
import androidx.recyclerview.widget.RecyclerView;
@RunWith(SettingsRobolectricTestRunner.class)
final ManageApplications fragment = mock(ManageApplications.class);
ReflectionHelpers.setField(fragment, "mLoadingContainer", mock(View.class));
ReflectionHelpers.setField(fragment, "mListContainer", mock(View.class));
- when(fragment.getActivity()).thenReturn(mock(Activity.class));
+ when(fragment.getActivity()).thenReturn(mock(FragmentActivity.class));
final ManageApplications.ApplicationsAdapter adapter =
spy(new ManageApplications.ApplicationsAdapter(mState, fragment,
AppFilterRegistry.getInstance().get(FILTER_APPS_ALL), new Bundle()));
final ManageApplications fragment = mock(ManageApplications.class);
ReflectionHelpers.setField(fragment, "mLoadingContainer", mock(View.class));
ReflectionHelpers.setField(fragment, "mListContainer", mock(View.class));
- when(fragment.getActivity()).thenReturn(mock(Activity.class));
+ when(fragment.getActivity()).thenReturn(mock(FragmentActivity.class));
final ManageApplications.ApplicationsAdapter adapter =
spy(new ManageApplications.ApplicationsAdapter(mState, fragment,
AppFilterRegistry.getInstance().get(FILTER_APPS_ALL), new Bundle()));
when(listContainer.getContext()).thenReturn(context);
ReflectionHelpers.setField(fragment, "mLoadingContainer", loadingContainer);
ReflectionHelpers.setField(fragment, "mListContainer", listContainer);
- when(fragment.getActivity()).thenReturn(mock(Activity.class));
+ when(fragment.getActivity()).thenReturn(mock(FragmentActivity.class));
final ManageApplications.ApplicationsAdapter adapter =
spy(new ManageApplications.ApplicationsAdapter(mState, fragment,
AppFilterRegistry.getInstance().get(FILTER_APPS_ALL), new Bundle()));
@Test
public void applicationsAdapter_onBindViewHolder_updateSwitch_notifications() {
ManageApplications manageApplications = mock(ManageApplications.class);
- when(manageApplications.getActivity()).thenReturn(mock(Activity.class));
+ when(manageApplications.getActivity()).thenReturn(mock(FragmentActivity.class));
UserManager um = mock(UserManager.class);
when(um.getProfileIdsWithDisabled(anyInt())).thenReturn(new int[]{});
ReflectionHelpers.setField(manageApplications, "mUserManager", um);
@Test
public void sortOrderSavedOnRebuild() {
ManageApplications manageApplications = mock(ManageApplications.class);
- when(manageApplications.getActivity()).thenReturn(mock(Activity.class));
+ when(manageApplications.getActivity()).thenReturn(mock(FragmentActivity.class));
UserManager um = mock(UserManager.class);
when(um.getProfileIdsWithDisabled(anyInt())).thenReturn(new int[]{});
ReflectionHelpers.setField(manageApplications, "mUserManager", um);
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.lifecycle.Lifecycle;
-import com.android.settingslib.widget.FooterPreferenceMixin;
+import com.android.settingslib.widget.FooterPreferenceMixinCompat;
import org.junit.Before;
import org.junit.Test;
public class DeviceAdminListPreferenceControllerTest {
@Mock
- private FooterPreferenceMixin mFooterPreferenceMixin;
+ private FooterPreferenceMixinCompat mFooterPreferenceMixin;
private Context mContext;
private DeviceAdminListPreferenceController mController;
private LifecycleOwner mLifecycleOwner;
// Verify that the intent returned by BackupSettingsHelper.getIntentForBackupSettings()
// was launched.
- assertThat(shadowOf(mApplication).getNextStartedActivity()).isEqualTo(mIntent);
+ assertThat(Shadows.shadowOf(mApplication).getNextStartedActivity()).isEqualTo(mIntent);
}
@Test
mActivityController.create();
- assertThat(shadowOf(mApplication).getNextStartedActivity()).isNull();
+ assertThat(Shadows.shadowOf(mApplication).getNextStartedActivity()).isNull();
verify(mFragmentTransaction).replace(anyInt(), isA(BackupSettingsFragment.class));
}
import com.android.settings.biometrics.fingerprint.FingerprintSettings.FingerprintSettingsFragment.DeleteFingerprintDialog;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowFragment;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import org.robolectric.util.FragmentTestUtil;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = ShadowFragment.class)
@Test
public void launchDialog_clickPositive_shouldDeleteFingerprint() {
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
mFragment.onClick(mFragment.getDialog(), Dialog.BUTTON_POSITIVE);
@Test
public void launchDialog_clickNegative_shouldDoNothing() {
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
mFragment.onClick(mFragment.getDialog(), Dialog.BUTTON_NEGATIVE);
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceScreen;
@RunWith(SettingsRobolectricTestRunner.class)
}
private static class TestController extends BluetoothDetailsController {
- private TestController(Context context, PreferenceFragment fragment,
+ private TestController(Context context, PreferenceFragmentCompat fragment,
CachedBluetoothDevice device, Lifecycle lifecycle) {
super(context, fragment, device, lifecycle);
}
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothClass;
import android.bluetooth.BluetoothDevice;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock
protected CachedBluetoothDevice mCachedDevice;
@Mock
- protected Activity mActivity;
+ protected FragmentActivity mActivity;
@Mock
protected BluetoothClass mBluetoothDeviceClass;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowAlertDialog;
-import org.robolectric.util.FragmentTestUtil;
@RunWith(SettingsRobolectricTestRunner.class)
public class BluetoothPairingDialogTest {
@Mock
private BluetoothPairingController controller;
-
@Mock
private BluetoothPairingDialog dialogActivity;
BluetoothPairingDialogFragment frag = new BluetoothPairingDialogFragment();
// this should throw an error
- FragmentTestUtil.startFragment(frag);
+ FragmentTestUtils.startFragment(frag);
fail("Starting the fragment with no controller set should have thrown an exception.");
}
frag.setPairingController(controller);
assertThat(frag.isPairingDialogActivitySet()).isFalse();
frag.setPairingDialogActivity(dialogActivity);
- FragmentTestUtil.startFragment(frag);
+ FragmentTestUtils.startFragment(frag);
assertThat(frag.getmDialog()).isNotNull();
assertThat(frag.isPairingControllerSet()).isTrue();
assertThat(frag.isPairingDialogActivitySet()).isTrue();
package com.android.settings.bluetooth;
+import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.app.AlertDialog;
import com.android.settings.testutils.FakeFeatureFactory;
import org.robolectric.Robolectric;
import org.robolectric.shadows.ShadowDialog;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class ForgetDeviceDialogFragmentTest {
private CachedBluetoothDevice mCachedDevice;
private ForgetDeviceDialogFragment mFragment;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private AlertDialog mDialog;
@Before
when(mCachedDevice.getAddress()).thenReturn(deviceAddress);
mFragment = spy(ForgetDeviceDialogFragment.newInstance(deviceAddress));
doReturn(mCachedDevice).when(mFragment).getDevice(any());
- mActivity = Robolectric.setupActivity(Activity.class);
- mActivity.getFragmentManager().beginTransaction().add(mFragment, null).commit();
+ mActivity = Robolectric.setupActivity(FragmentActivity.class);
+ mActivity.getSupportFragmentManager().beginTransaction().add(mFragment, null).commit();
mDialog = (AlertDialog) ShadowDialog.getLatestDialog();
}
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.bluetooth.LocalBluetoothAdapter;
import com.android.settingslib.bluetooth.LocalBluetoothManager;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.After;
import org.junit.Before;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowAlertDialog;
-import org.robolectric.util.FragmentTestUtil;
import org.robolectric.util.ReflectionHelpers;
@RunWith(SettingsRobolectricTestRunner.class)
@Test
public void diaglogTriggersShowSoftInput() {
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
AlertDialog dialog = ShadowAlertDialog.getLatestAlertDialog();
assertThat(dialog).isNotNull();
View view = dialog.findViewById(R.id.edittext);
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
@RunWith(SettingsRobolectricTestRunner.class)
public class RemoteDeviceNameDialogFragmentTest {
*/
AlertDialog startDialog(String deviceName) {
when(mCachedDevice.getName()).thenReturn(deviceName);
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
return (AlertDialog) ShadowDialog.getLatestDialog();
}
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.shadows.ShadowNfcAdapter;
import org.robolectric.util.ReflectionHelpers;
mContentResolver = mContext.getContentResolver();
mNfcController = new NfcPreferenceController(mContext,
NfcPreferenceController.KEY_TOGGLE_NFC);
- mShadowNfcAdapter = shadowOf(ShadowNfcAdapter.getNfcAdapter(mContext));
+ mShadowNfcAdapter = Shadows.shadowOf(ShadowNfcAdapter.getNfcAdapter(mContext));
}
@Test
import com.android.settings.testutils.shadow.ShadowBluetoothPan;
import com.android.settings.testutils.shadow.ShadowLocalBluetoothAdapter;
import com.android.settingslib.widget.FooterPreference;
-import com.android.settingslib.widget.FooterPreferenceMixin;
+import com.android.settingslib.widget.FooterPreferenceMixinCompat;
import org.junit.Before;
import org.junit.Test;
@Mock
private PreferenceScreen mScreen;
@Mock
- private FooterPreferenceMixin mFooterPreferenceMixin;
+ private FooterPreferenceMixinCompat mFooterPreferenceMixin;
@Mock
private AlwaysDiscoverable mAlwaysDiscoverable;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock
private UsbDetailsFragment mFragment;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private Handler mHandler;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import java.util.Iterator;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock
private UsbDetailsFragment mFragment;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Before
public void setUp() {
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock
private UsbDetailsFragment mFragment;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private EntityHeaderController mHeaderController;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock
private UsbDetailsFragment mFragment;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private Handler mHandler;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.os.Bundle;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import org.mockito.MockitoAnnotations;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Mock
private PreferenceManager mPreferenceManager;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
private InstrumentedPreferenceFragmentTestable mFragment;
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.os.UserHandle;
import org.robolectric.RuntimeEnvironment;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
@RunWith(SettingsRobolectricTestRunner.class)
public class SubSettingLauncherTest {
@Mock
private Fragment mFragment;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
private Context mContext;
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;
import org.robolectric.shadows.ShadowApplication;
mImpl.bindPreferenceToTile(activity, MetricsProto.MetricsEvent.SETTINGS_GESTURES,
preference, tile, "123", Preference.DEFAULT_ORDER);
preference.performClick();
- ShadowActivity shadowActivity = shadowOf(activity);
+ ShadowActivity shadowActivity = Shadows.shadowOf(activity);
final Intent launchIntent = shadowActivity.getNextStartedActivityForResult().intent;
assertThat(launchIntent.getAction())
preference.performClick();
final ShadowActivity.IntentForResult launchIntent =
- shadowOf(activity).getNextStartedActivityForResult();
+ Shadows.shadowOf(activity).getNextStartedActivityForResult();
assertThat(launchIntent).isNull();
}
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.drawer.CategoryKey;
import com.android.settingslib.drawer.DashboardCategory;
-import com.android.settingslib.suggestions.SuggestionControllerMixin;
+import com.android.settingslib.suggestions.SuggestionControllerMixinCompat;
import org.junit.Before;
import org.junit.Test;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
@RunWith(SettingsRobolectricTestRunner.class)
@Mock
private SummaryLoader mSummaryLoader;
@Mock
- private SuggestionControllerMixin mSuggestionControllerMixin;
+ private SuggestionControllerMixinCompat mSuggestionControllerMixin;
private Context mContext;
private DashboardSummary mSummary;
.thenReturn(false);
mSummary.onAttach(mContext);
- final SuggestionControllerMixin mixin = ReflectionHelpers
+ final SuggestionControllerMixinCompat mixin = ReflectionHelpers
.getField(mSummary, "mSuggestionControllerMixin");
assertThat(mixin).isNull();
}
.thenReturn(true);
mSummary.onAttach(mContext);
- final SuggestionControllerMixin mixin = ReflectionHelpers
+ final SuggestionControllerMixinCompat mixin = ReflectionHelpers
.getField(mSummary, "mSuggestionControllerMixin");
assertThat(mixin).isNotNull();
}
mSuggestionControllerMixin);
when(mSuggestionControllerMixin.isSuggestionLoaded()).thenReturn(true);
- doReturn(mock(Activity.class)).when(mSummary).getActivity();
+ doReturn(mock(FragmentActivity.class)).when(mSummary).getActivity();
mSummary.onAttach(mContext);
mSummary.updateCategory();
when(mFeatureFactory.suggestionsFeatureProvider.isSuggestionEnabled(any(Context.class)))
.thenReturn(false);
- doReturn(mock(Activity.class)).when(mSummary).getActivity();
+ doReturn(mock(FragmentActivity.class)).when(mSummary).getActivity();
mSummary.onAttach(mContext);
mSummary.updateCategory();
@Test
public void onCategoryChanged_noRebuildOnFirstCall() {
- doReturn(mock(Activity.class)).when(mSummary).getActivity();
+ doReturn(mock(FragmentActivity.class)).when(mSummary).getActivity();
doNothing().when(mSummary).rebuildUI();
mSummary.onCategoriesChanged();
verify(mSummary, never()).rebuildUI();
@Test
public void onCategoryChanged_rebuildOnSecondCall() {
- doReturn(mock(Activity.class)).when(mSummary).getActivity();
+ doReturn(mock(FragmentActivity.class)).when(mSummary).getActivity();
doNothing().when(mSummary).rebuildUI();
mSummary.onCategoriesChanged();
mSummary.onCategoriesChanged();
*/
package com.android.settings.dashboard.conditional;
+import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowCardView;
import com.android.settingslib.Utils;
-import com.android.settingslib.suggestions.SuggestionControllerMixin;
+import com.android.settingslib.suggestions.SuggestionControllerMixinCompat;
import com.android.settingslib.utils.IconCache;
import org.junit.Before;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private SettingsActivity mActivity;
@Mock
- private SuggestionControllerMixin mSuggestionControllerMixin;
+ private SuggestionControllerMixinCompat mSuggestionControllerMixin;
@Mock
private Resources mResources;
@Mock
import com.android.settings.testutils.shadow.SettingsShadowResources;
import com.android.settings.testutils.shadow.ShadowSecureSettings;
import com.android.settingslib.drawer.Tile;
-import com.android.settingslib.suggestions.SuggestionControllerMixin;
+import com.android.settingslib.suggestions.SuggestionControllerMixinCompat;
import org.junit.After;
import org.junit.Before;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock
- private SuggestionControllerMixin mSuggestionControllerMixin;
+ private SuggestionControllerMixinCompat mSuggestionControllerMixin;
@Mock
private Suggestion mSuggestion;
@Mock
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.net.NetworkTemplate;
import org.mockito.MockitoAnnotations;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class DataUsageListTest {
@Test
public void processArgument_fromIntent_shouldGetTemplateFromIntent() {
- final Activity activity = mock(Activity.class);
+ final FragmentActivity activity = mock(FragmentActivity.class);
final Intent intent = new Intent();
intent.putExtra(Settings.EXTRA_NETWORK_TEMPLATE, mock(NetworkTemplate.class));
intent.putExtra(Settings.EXTRA_SUB_ID, 3);
import java.util.concurrent.TimeUnit;
+import androidx.fragment.app.FragmentActivity;
import androidx.recyclerview.widget.RecyclerView;
@RunWith(SettingsRobolectricTestRunner.class)
private DataUsageInfoController mDataInfoController;
private FakeFeatureFactory mFactory;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private Context mContext;
private DataUsageSummaryPreferenceController mController;
ShadowEntityHeaderController.setUseMock(mHeaderController);
mDataInfoController = new DataUsageInfoController();
- mActivity = spy(Robolectric.buildActivity(Activity.class).get());
+ mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get());
when(mActivity.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);
when(mActivity.getSystemService(ConnectivityManager.class))
.thenReturn(mConnectivityManager);
import java.util.concurrent.TimeUnit;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceViewHolder;
@RunWith(SettingsRobolectricTestRunner.class)
@Test
public void testSetAppIntent_toMdpApp_intentCorrect() {
- final Activity activity = Robolectric.setupActivity(Activity.class);
+ final FragmentActivity activity = Robolectric.setupActivity(FragmentActivity.class);
final Intent intent = new Intent(SubscriptionManager.ACTION_MANAGE_SUBSCRIPTION_PLANS);
intent.setPackage("test-owner.example.com");
intent.putExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX, 42);
final int daysLeft = 3;
final long cycleEnd = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(daysLeft)
+ TimeUnit.HOURS.toMillis(1);
- final Activity activity = Robolectric.setupActivity(Activity.class);
+ final FragmentActivity activity = Robolectric.setupActivity(FragmentActivity.class);
mSummaryPreference = spy(mSummaryPreference);
mSummaryPreference.setUsageInfo(cycleEnd, mUpdateTime, DUMMY_CARRIER, 0 /* numPlans */,
new Intent());
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
-import android.app.Activity;
import android.content.Context;
import android.net.NetworkPolicyManager;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
+import androidx.fragment.app.FragmentActivity;
+
@Config(shadows = {
SettingsShadowResourcesImpl.class,
SettingsShadowResources.SettingsShadowTheme.class,
@Mock
private NetworkPolicyManager mNetworkPolicyManager;
private Context mContext;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private SummaryLoader.SummaryProvider mSummaryProvider;
/**
shadowContext.setSystemService(Context.NETWORK_POLICY_SERVICE, mNetworkPolicyManager);
mContext = shadowContext.getApplicationContext();
- mActivity = spy(Robolectric.buildActivity(Activity.class).get());
+ mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get());
mSummaryProvider = DataUsageSummary.SUMMARY_PROVIDER_FACTORY
.createSummaryProvider(mActivity, mSummaryLoader);
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.widget.Filter;
import android.widget.LinearLayout;
import com.android.settings.datetime.timezone.BaseTimeZoneAdapter.ItemViewHolder;
import com.android.settings.datetime.timezone.RegionSearchPicker.RegionItem;
import com.android.settings.datetime.timezone.model.TimeZoneData;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import libcore.util.CountryZonesFinder;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.Implementation;
import java.util.Locale;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {
@Implements(Fragment.class)
public static class ShadowFragment {
- private Activity mActivity = Robolectric.setupActivity(Activity.class);
+ private FragmentActivity mActivity = Robolectric.setupActivity(FragmentActivity.class);
@Implementation
- public final Activity getActivity() {
+ public final FragmentActivity getActivity() {
return mActivity;
}
}
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.content.ComponentName;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
-import android.app.Activity;
import android.os.SystemProperties;
import android.view.View;
import com.android.settings.R;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
+
+import androidx.fragment.app.FragmentActivity;
@RunWith(SettingsRobolectricTestRunner.class)
public class HardwareInfoDialogFragmentTest {
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Before
public void setUp() {
- mActivity = Robolectric.setupActivity(Activity.class);
+ mActivity = Robolectric.setupActivity(FragmentActivity.class);
}
@Test
final HardwareInfoDialogFragment fragment = spy(HardwareInfoDialogFragment.newInstance());
doReturn("").when(fragment).getSerialNumber();
- fragment.show(mActivity.getFragmentManager(), HardwareInfoDialogFragment.TAG);
+ fragment.show(mActivity.getSupportFragmentManager(), HardwareInfoDialogFragment.TAG);
verify(fragment).setText(
any(View.class), eq(R.id.model_label), eq(R.id.model_value),
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.os.Bundle;
import java.util.List;
import java.util.Map;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
@RunWith(SettingsRobolectricTestRunner.class)
public class MyDeviceInfoFragmentTest {
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private PreferenceScreen mScreen;
@Mock
import static com.google.common.truth.Truth.assertThat;
-import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import com.android.settings.R;
import com.android.settings.deviceinfo.PrivateVolumeForget.ForgetConfirmFragment;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowStorageManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = ShadowStorageManager.class)
public class PrivateVolumeForgetTest {
private PrivateVolumeForget mFragment;
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Before
public void setUp() {
confirm.performClick();
final ForgetConfirmFragment confirmFragment =
- (ForgetConfirmFragment) mActivity.getFragmentManager().findFragmentByTag(
+ (ForgetConfirmFragment) mActivity.getSupportFragmentManager().findFragmentByTag(
PrivateVolumeForget.TAG_FORGET_CONFIRM);
assertThat(confirmFragment).isNotNull();
import android.widget.Button;
import com.android.settings.R;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowStorageManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowActivity;
bundle.putString(VolumeInfo.EXTRA_VOLUME_ID, "id");
mFragment = Robolectric.buildFragment(PrivateVolumeFormat.class,
bundle).create().start().resume().get();
- mShadowActivity = shadowOf(mFragment.getActivity());
+ mShadowActivity = Shadows.shadowOf(mFragment.getActivity());
}
@Test
import android.widget.Button;
import com.android.settings.R;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowStorageManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
import com.android.settings.deviceinfo.aboutphone.DeviceNameWarningDialog;
import com.android.settings.deviceinfo.aboutphone.MyDeviceInfoFragment;
+import com.android.settings.testutils.FragmentController;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
-import org.robolectric.android.controller.FragmentController;
@RunWith(SettingsRobolectricTestRunner.class)
public class DeviceNameWarningDialogTest {
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.graphics.drawable.Drawable;
import org.robolectric.RuntimeEnvironment;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import androidx.preference.PreferenceScreen;
@Mock
private StorageVolumeProvider mSvp;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private FragmentManager mFragmentManager;
@Mock
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.os.Bundle;
import com.android.internal.app.ColorDisplayController;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
private ColorDisplayController mController;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Before
public void setup() {
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.app.AppOpsManager;
import android.content.Context;
import android.content.Intent;
import java.util.ArrayList;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
import androidx.loader.app.LoaderManager;
import androidx.preference.Preference;
import androidx.recyclerview.widget.RecyclerView;
private static final long PHONE_BACKGROUND_TIME_MS = 0;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private EntityHeaderController mEntityHeaderController;
@Mock
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.ShadowPowerManager;
import androidx.lifecycle.LifecycleOwner;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceScreen;
import androidx.recyclerview.widget.RecyclerView;
@Mock
private Activity mActivity;
@Mock
- private PreferenceFragment mPreferenceFragment;
+ private PreferenceFragmentCompat mPreferenceFragment;
@Mock
private PreferenceScreen mPreferenceScreen;
@Mock
public void testQuickUpdateHeaderPreference_showPowerSave() {
boolean testValues[] = {false, true};
- ShadowPowerManager shadowPowerManager = shadowOf(mPowerManager);
+ ShadowPowerManager shadowPowerManager = Shadows.shadowOf(mPowerManager);
for (boolean value : testValues) {
shadowPowerManager.setIsPowerSaveMode(value);
mController.quickUpdateHeaderPreference();
import com.android.settings.fuelgauge.batterytip.tips.RestrictAppTip;
import com.android.settings.fuelgauge.batterytip.tips.UnrestrictAppTip;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowAlertDialog;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
import java.util.ArrayList;
import java.util.List;
final BatteryTipDialogFragment dialogFragment = mRestrictedAppDetails.createDialogFragment(
mAppInfo, true);
- FragmentTestUtil.startFragment(dialogFragment);
+ FragmentTestUtils.startFragment(dialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getTitle()).isEqualTo("Restrict app?");
}
final BatteryTipDialogFragment dialogFragment = mRestrictedAppDetails.createDialogFragment(
mAppInfo, false);
- FragmentTestUtil.startFragment(dialogFragment);
+ FragmentTestUtils.startFragment(dialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getTitle()).isEqualTo("Remove restriction?");
}
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowRuntimePermissionPresenter;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
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.ShadowAlertDialog;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = ShadowRuntimePermissionPresenter.class)
public void testOnCreateDialog_hasCorrectData() {
mAnomalyDialogFragment =
AnomalyDialogFragment.newInstance(mWakeLockAnomaly, 0 /* metricskey */);
- FragmentTestUtil.startFragment(mAnomalyDialogFragment);
+ FragmentTestUtils.startFragment(mAnomalyDialogFragment);
assertThat(mAnomalyDialogFragment.mAnomaly).isEqualTo(mWakeLockAnomaly);
}
mAnomalyDialogFragment =
AnomalyDialogFragment.newInstance(mWakeLockAnomaly, 0 /* metricskey */);
- FragmentTestUtil.startFragment(mAnomalyDialogFragment);
+ FragmentTestUtils.startFragment(mAnomalyDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.dialog_stop_message, mWakeLockAnomaly.displayName));
mAnomalyDialogFragment =
AnomalyDialogFragment.newInstance(mWakeupAlarmAnomaly, 0 /* metricskey */);
- FragmentTestUtil.startFragment(mAnomalyDialogFragment);
+ FragmentTestUtils.startFragment(mAnomalyDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.dialog_background_check_message,
mAnomalyDialogFragment =
AnomalyDialogFragment.newInstance(mWakeupAlarmAnomaly2, 0 /* metricskey */);
- FragmentTestUtil.startFragment(mAnomalyDialogFragment);
+ FragmentTestUtils.startFragment(mAnomalyDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.dialog_stop_message_wakeup_alarm,
doNothing().when(mAnomalyDialogFragment).initAnomalyUtils();
doReturn(Anomaly.AnomalyActionType.LOCATION_CHECK).when(mAnomalyAction).getActionType();
- FragmentTestUtil.startFragment(mAnomalyDialogFragment);
+ FragmentTestUtils.startFragment(mAnomalyDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
assertThat(dialog).isNotNull();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.dialog_location_message,
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowUtils;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
import org.junit.Test;
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.ShadowAlertDialog;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
import java.util.ArrayList;
import java.util.List;
mDialogFragment = BatteryTipDialogFragment.newInstance(mHighUsageTip, METRICS_KEY);
- FragmentTestUtil.startFragment(mDialogFragment);
+ FragmentTestUtils.startFragment(mDialogFragment);
Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable();
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.battery_tip_dialog_message, 1));
public void testOnCreateDialog_restrictOneAppTip_fireRestrictOneAppDialog() {
mDialogFragment = BatteryTipDialogFragment.newInstance(mRestrictedOneAppTip, METRICS_KEY);
- FragmentTestUtil.startFragment(mDialogFragment);
+ FragmentTestUtils.startFragment(mDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getTitle()).isEqualTo("Restrict app?");
assertThat(shadowDialog.getMessage())
mDialogFragment = BatteryTipDialogFragment.newInstance(mRestrictTwoAppsTip, METRICS_KEY);
- FragmentTestUtil.startFragment(mDialogFragment);
+ FragmentTestUtils.startFragment(mDialogFragment);
Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable();
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getTitle()).isEqualTo("Restrict 2 apps?");
assertThat(shadowDialog.getMessage())
mDialogFragment = BatteryTipDialogFragment.newInstance(restrictSixAppsTip, METRICS_KEY);
- FragmentTestUtil.startFragment(mDialogFragment);
+ FragmentTestUtils.startFragment(mDialogFragment);
Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable();
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getTitle()).isEqualTo("Restrict 6 apps?");
assertThat(shadowDialog.getMessage())
mDialogFragment = BatteryTipDialogFragment.newInstance(mUnrestrictAppTip, METRICS_KEY);
ShadowUtils.setApplicationLabel(PACKAGE_NAME, DISPLAY_NAME);
- FragmentTestUtil.startFragment(mDialogFragment);
+ FragmentTestUtils.startFragment(mDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getTitle()).isEqualTo("Remove restriction?");
assertThat(shadowDialog.getMessage())
doReturn(AVERAGE_TIME_MS).when(mSummaryTip).getAverageTimeMs();
mDialogFragment = BatteryTipDialogFragment.newInstance(mSummaryTip, METRICS_KEY);
- FragmentTestUtil.startFragment(mDialogFragment);
+ FragmentTestUtils.startFragment(mDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
- ShadowAlertDialog shadowDialog = shadowOf(dialog);
+ ShadowAlertDialog shadowDialog = Shadows.shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
"Your apps are using a normal amount of battery. If apps use too much battery, "
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class InputMethodAndSubtypeEnablerTest {
- private Activity mActivity;
+ private FragmentActivity mActivity;
private InputMethodAndSubtypeEnabler mFragment;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mActivity = Robolectric.setupActivity(Activity.class);
+ mActivity = Robolectric.setupActivity(FragmentActivity.class);
mFragment = spy(new InputMethodAndSubtypeEnabler());
when(mFragment.getActivity()).thenReturn(mActivity);
}
import java.util.ArrayList;
import java.util.List;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
public class InputMethodAndSubtypePreferenceControllerTest {
@Mock
- private PreferenceFragment mFragment;
+ private PreferenceFragmentCompat mFragment;
private Context mContext;
private InputMethodAndSubtypePreferenceController mController;
private PreferenceManager mPreferenceManager;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.hardware.input.InputDeviceIdentifier;
import android.hardware.input.InputManager;
import org.robolectric.shadows.ShadowApplication;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
@Test
public void testLifecycle_onStart_shouldRegisterInputManager() {
- final Activity activity = Robolectric.setupActivity(Activity.class);
+ final FragmentActivity activity = Robolectric.setupActivity(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(activity);
mController.onStart();
@Test
public void testLifecycle_onStart_NoInputDevice_shouldFinish() {
- final Activity activity = Robolectric.setupActivity(Activity.class);
+ final FragmentActivity activity = Robolectric.setupActivity(FragmentActivity.class);
when(mInputManager.getInputDeviceByDescriptor(anyString())).thenReturn(null);
when(mFragment.getActivity()).thenReturn(activity);
@Config(shadows = ShadowInputDevice.class)
public void testOnDeviceRemove_getSameDevice_shouldFinish() {
final int TARGET_DEVICE_ID = 1;
- final Activity activity = Robolectric.setupActivity(Activity.class);
+ final FragmentActivity activity = Robolectric.setupActivity(FragmentActivity.class);
final String[] enableKeyboardLayouts = {"layout1"};
final InputDevice device = ShadowInputDevice.makeInputDevicebyId(TARGET_DEVICE_ID);
public void testOnDeviceRemove_getDifferentDevice_shouldNotFinish() {
final int TARGET_DEVICE_ID = 1;
final int ANOTHER_DEVICE_ID = 2;
- final Activity activity = Robolectric.setupActivity(Activity.class);
+ final FragmentActivity activity = Robolectric.setupActivity(FragmentActivity.class);
final String[] enableKeyboardLayouts = {"layout1"};
final InputDevice device = ShadowInputDevice.makeInputDevicebyId(TARGET_DEVICE_ID);
lifecycleObserverCount++;
}
}
- verify(mFragment.getLifecycle(), times(lifecycleObserverCount))
+ verify(mFragment.getSettingsLifecycle(), times(lifecycleObserverCount))
.addObserver(any(LifecycleObserver.class));
}
}
@Override
- public Lifecycle getLifecycle() {
+ public Lifecycle getSettingsLifecycle() {
if (mLifecycle == null) {
- return super.getLifecycle();
+ return super.getSettingsLifecycle();
}
return mLifecycle;
}
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import com.android.settings.R;
import com.android.settings.network.ApnEditor.ApnData;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.robolectric.Robolectric;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.EditTextPreference;
import androidx.preference.ListPreference;
import androidx.preference.MultiSelectListPreference;
private ArgumentCaptor<Uri> mUriCaptor;
private ApnEditor mApnEditorUT;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private Resources mResources;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mActivity = spy(Robolectric.setupActivity(Activity.class));
+ mActivity = spy(Robolectric.setupActivity(FragmentActivity.class));
mResources = mActivity.getResources();
mApnEditorUT = spy(new ApnEditor());
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowOs;
-import com.android.settingslib.CustomDialogPreference.CustomPreferenceDialogFragment;
+import com.android.settingslib.CustomDialogPreferenceCompat.CustomPreferenceDialogFragment;
import org.junit.Before;
import org.junit.Test;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.Global;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
@Mock
private PreferenceScreen mScreen;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.System;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
@Mock
private PreferenceScreen mScreen;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.Global;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.DropDownPreference;
import androidx.preference.PreferenceScreen;
@Mock
private PreferenceScreen mScreen;
@Mock(answer = RETURNS_DEEP_STUBS)
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.Global;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
@Mock
private PreferenceScreen mScreen;
@Mock(answer = RETURNS_DEEP_STUBS)
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.Global;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.DropDownPreference;
import androidx.preference.PreferenceScreen;
@Mock
private PreferenceScreen mScreen;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.app.NotificationChannel;
import android.app.NotificationChannelGroup;
import android.app.NotificationManager;
import org.mockito.MockitoAnnotations;
import org.robolectric.shadows.ShadowApplication;
+import androidx.fragment.app.FragmentActivity;
+import androidx.preference.PreferenceFragmentCompat;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class HeaderPreferenceControllerTest {
shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNm);
shadowApplication.setSystemService(Context.USER_SERVICE, mUm);
mContext = shadowApplication.getApplicationContext();
- PreferenceFragment fragment = mock(PreferenceFragment.class);
+ PreferenceFragmentCompat fragment = mock(PreferenceFragmentCompat.class);
when(fragment.getContext()).thenReturn(mContext);
- Activity activity = mock(Activity.class);
+ FragmentActivity activity = mock(FragmentActivity.class);
when(activity.getApplicationContext()).thenReturn(mContext);
when(fragment.getActivity()).thenReturn(activity);
mController = spy(new HeaderPreferenceController(mContext, fragment));
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.ApplicationInfo;
import java.util.List;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceScreen;
@Mock
private Fragment mHost;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
private Context mContext;
private RecentNotifyingAppsPreferenceController mController;
private void setupActivity() {
mActivity = buildActivity(RedactionInterstitial.class, new Intent()).setup().get();
mFragment = (RedactionInterstitialFragment)
- mActivity.getFragmentManager().findFragmentById(R.id.main_content);
+ mActivity.getSupportFragmentManager().findFragmentById(R.id.main_content);
assertThat(mActivity).isNotNull();
assertThat(mFragment).isNotNull();
}
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.System;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
@Mock
private PreferenceScreen mScreen;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.Global;
import java.util.ArrayList;
import java.util.List;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
@RunWith(SettingsRobolectricTestRunner.class)
@Mock
private SoundSettings mSetting;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
@Mock
private PreferenceScreen mScreen;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.os.Vibrator;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
@Mock
private PreferenceScreen mScreen;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private ContentResolver mContentResolver;
@Mock
import static org.mockito.Mockito.when;
import static org.robolectric.RuntimeEnvironment.application;
-import android.app.Activity;
import android.app.NotificationManager;
import android.content.Context;
import android.content.Intent;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.shadows.ShadowToast;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = SettingsShadowResources.SettingsShadowTheme.class)
public class ZenModeScheduleRuleSettingsTest {
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private Intent mIntent;
private ChooseLockPasswordFragment getChooseLockPasswordFragment(ChooseLockPassword activity) {
return (ChooseLockPasswordFragment)
- activity.getFragmentManager().findFragmentById(R.id.main_content);
+ activity.getSupportFragmentManager().findFragmentById(R.id.main_content);
}
private ShadowDrawable setActivityAndGetIconDrawable(boolean addFingerprintExtra) {
public void fingerprintExtraSet_shouldDisplayFingerprintIcon() {
ChooseLockPattern activity = createActivity(true);
ChooseLockPatternFragment fragment = (ChooseLockPatternFragment)
- activity.getFragmentManager().findFragmentById(R.id.main_content);
+ activity.getSupportFragmentManager().findFragmentById(R.id.main_content);
ShadowDrawable drawable = Shadows.shadowOf(((GlifLayout) fragment.getView()).getIcon());
assertThat(drawable.getCreatedFromResId()).isEqualTo(R.drawable.ic_fingerprint_header);
public void smallScreens_shouldHideIcon() {
ChooseLockPattern activity = createActivity(true);
ChooseLockPatternFragment fragment = (ChooseLockPatternFragment)
- activity.getFragmentManager().findFragmentById(R.id.main_content);
+ activity.getSupportFragmentManager().findFragmentById(R.id.main_content);
View iconView = fragment.getView().findViewById(R.id.suw_layout_icon);
assertThat(iconView.getVisibility()).isEqualTo(View.GONE);
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.testutils.shadow.ShadowUtils;
+import com.android.settingslib.testutils.FragmentTestUtils;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowAlertDialog;
import org.robolectric.shadows.ShadowDialog;
-import org.robolectric.util.FragmentTestUtil;
import androidx.fragment.app.Fragment;
public void setUp() {
mContext = RuntimeEnvironment.application;
mFragment = new TestFragment();
- FragmentTestUtil.startFragment(mFragment);
+ FragmentTestUtils.startFragment(mFragment);
}
@Test
+ @Ignore("b/111247403")
public void testThatDialog_IsShown() {
AlertDialog latestDialog = startLockFragment();
assertNotNull(latestDialog);
}
@Test
+ @Ignore("b/111247403")
public void testThat_OnClickListener_IsCalled() {
mFragment.mDelegate = mock(OnLockTypeSelectedListener.class);
AlertDialog lockDialog = startLockFragment();
}
@Test
+ @Ignore("b/111247403")
public void testThat_OnClickListener_IsNotCalledWhenCancelled() {
mFragment.mDelegate = mock(OnLockTypeSelectedListener.class);
AlertDialog lockDialog = startLockFragment();
verify(mFragment.mDelegate, never()).onLockTypeSelected(any(ScreenLockType.class));
}
-
private AlertDialog startLockFragment() {
ChooseLockTypeDialogFragment chooseLockTypeDialogFragment =
ChooseLockTypeDialogFragment.newInstance(1234);
import static com.google.common.truth.Truth.assertThat;
-import android.app.Activity;
-
import com.android.settings.password.ConfirmDeviceCredentialBaseFragment.LastTryDialog;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.annotation.Config;
+import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentManager;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = SettingsShadowResources.SettingsShadowTheme.class)
public class ConfirmCredentialTest {
@Test
+ @Ignore("b/111193572")
public void testLastTryDialogShownExactlyOnce() {
- FragmentManager fm = Robolectric.buildActivity(Activity.class).get().getFragmentManager();
+ FragmentManager fm = Robolectric.buildActivity(FragmentActivity.class).
+ get().getSupportFragmentManager();
// Launch only one instance at a time.
assertThat(LastTryDialog.show(
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowActivity;
@RunWith(SettingsRobolectricTestRunner.class)
SetNewPasswordActivity activity =
Robolectric.buildActivity(SetNewPasswordActivity.class).get();
activity.launchChooseLock(new Bundle());
- ShadowActivity shadowActivity = shadowOf(activity);
+ ShadowActivity shadowActivity = Shadows.shadowOf(activity);
Intent intent = shadowActivity.getNextStartedActivityForResult().intent;
assertThat(intent.getComponent())
SetNewPasswordActivity activity =
Robolectric.buildActivity(SetNewPasswordActivity.class).get();
activity.launchChooseLock(new Bundle());
- ShadowActivity shadowActivity = shadowOf(activity);
+ ShadowActivity shadowActivity = Shadows.shadowOf(activity);
Intent intent = shadowActivity.getNextStartedActivityForResult().intent;
assertThat(intent.getComponent())
import com.android.settings.password.ChooseLockGeneric.ChooseLockGenericFragment;
import com.android.settings.password.ChooseLockPassword.IntentBuilder;
import com.android.settings.password.SetupChooseLockPassword.SetupChooseLockPasswordFragment;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
import com.android.settings.testutils.shadow.SettingsShadowResourcesImpl;
import org.junit.After;
import org.junit.Before;
+import org.junit.Ignore;
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.annotation.Implementation;
}
@Test
+ @Ignore("b/111194289")
public void createActivity_withShowOptionsButtonExtra_shouldShowButton() {
SetupChooseLockPassword activity = createSetupChooseLockPassword();
Button optionsButton = activity.findViewById(R.id.screen_lock_options);
}
@Test
+ @Ignore("b/111194289")
public void allSecurityOptions_shouldBeShown_When_OptionsButtonIsClicked() {
SetupChooseLockPassword activity = createSetupChooseLockPassword();
activity.findViewById(R.id.screen_lock_options).performClick();
Robolectric.buildActivity(SetupChooseLockPassword.class, intent).setup().get();
SetupChooseLockPasswordFragment fragment =
- (SetupChooseLockPasswordFragment) activity.getFragmentManager()
+ (SetupChooseLockPasswordFragment) activity.getSupportFragmentManager()
.findFragmentById(R.id.main_content);
fragment.onLockTypeSelected(ScreenLockType.PATTERN);
- ShadowActivity shadowActivity = shadowOf(activity);
+ ShadowActivity shadowActivity = Shadows.shadowOf(activity);
final Intent nextStartedActivity = shadowActivity.getNextStartedActivity();
assertThat(nextStartedActivity).isNotNull();
assertThat(nextStartedActivity.getBooleanExtra(
import static com.google.common.truth.Truth.assertThat;
import static org.robolectric.RuntimeEnvironment.application;
-import android.app.Activity;
import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.pm.PackageManager;
import com.android.settings.SetupRedactionInterstitial;
import com.android.settings.password.ChooseLockPattern.ChooseLockPatternFragment;
import com.android.settings.password.ChooseLockPattern.IntentBuilder;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
import com.android.settings.testutils.shadow.SettingsShadowResourcesImpl;
import com.android.settings.testutils.shadow.ShadowUtils;
import org.junit.Before;
+import org.junit.Ignore;
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.ShadowAlertDialog;
import java.util.Arrays;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {
SettingsShadowResourcesImpl.class,
@Config(qualifiers = "sw400dp")
@Test
+ @Ignore("b/111194289")
public void sw400dp_shouldShowScreenLockOptions() {
verifyScreenLockOptionsShown();
}
@Config(qualifiers = "sw400dp-land")
@Test
+ @Ignore("b/111194289")
public void sw400dpLandscape_shouldShowScreenLockOptions() {
verifyScreenLockOptionsShown();
}
assertThat(skipButton.getVisibility()).isEqualTo(View.GONE);
}
- private ChooseLockPatternFragment findFragment(Activity activity) {
+ private ChooseLockPatternFragment findFragment(FragmentActivity activity) {
return (ChooseLockPatternFragment)
- activity.getFragmentManager().findFragmentById(R.id.main_content);
+ activity.getSupportFragmentManager().findFragmentById(R.id.main_content);
}
private void enterPattern() {
package com.android.settings.password;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import android.app.Activity;
import android.app.AlertDialog;
import com.android.settings.R;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.SettingsShadowResources;
import com.android.settings.testutils.shadow.ShadowUtils;
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.ShadowAlertDialog;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
@Config(shadows = {
SettingsShadowResources.SettingsShadowTheme.class,
})
public class SetupSkipDialogTest {
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Before
public void setUp() {
- mActivity = Robolectric.setupActivity(Activity.class);
+ mActivity = Robolectric.setupActivity(FragmentActivity.class);
}
@Test
public void frpMessages_areShownCorrectly_whenNotSupported() {
SetupSkipDialog setupSkipDialog = SetupSkipDialog.newInstance(false);
- setupSkipDialog.show(mActivity.getFragmentManager());
+ setupSkipDialog.show(mActivity.getSupportFragmentManager());
AlertDialog alertDialog = ShadowAlertDialog.getLatestAlertDialog();
assertNotNull(alertDialog);
@Test
public void frpMessages_areShownCorrectly_whenSupported() {
SetupSkipDialog setupSkipDialog = SetupSkipDialog.newInstance(true);
- setupSkipDialog.show(mActivity.getFragmentManager());
+ setupSkipDialog.show(mActivity.getSupportFragmentManager());
AlertDialog alertDialog = ShadowAlertDialog.getLatestAlertDialog();
assertNotNull(alertDialog);
import android.view.MenuItem;
import com.android.settings.R;
-import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.lifecycle.ObservableFragment;
import com.android.settingslib.core.lifecycle.ObservablePreferenceFragment;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@Test
public void init_prefFragment_shouldAddMenu() {
SearchMenuController.init(mPreferenceHost);
- mPreferenceHost.getLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */);
+ mPreferenceHost.getSettingsLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */);
verify(mMenu).add(Menu.NONE, Menu.NONE, 0 /* order */, R.string.search_menu);
}
@Test
public void init_observableFragment_shouldAddMenu() {
SearchMenuController.init(mHost);
- mHost.getLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */);
+ mHost.getSettingsLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */);
verify(mMenu).add(Menu.NONE, Menu.NONE, 0 /* order */, R.string.search_menu);
}
mHost.setArguments(args);
SearchMenuController.init(mHost);
- mHost.getLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */);
+ mHost.getSettingsLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */);
verifyZeroInteractions(mMenu);
}
import android.content.DialogInterface;
+import com.android.settings.testutils.FragmentController;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.robolectric.Robolectric;
-import org.robolectric.android.controller.FragmentController;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class ConfigureKeyGuardDialogTest {
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
+import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceManager;
import androidx.preference.PreferenceScreen;
public class OwnerInfoPreferenceControllerTest {
@Mock
- private PreferenceFragment mFragment;
+ private PreferenceFragmentCompat mFragment;
@Mock
private PreferenceScreen mScreen;
@Mock
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadow.api.Shadow;
import org.robolectric.shadows.ShadowBluetoothDevice;
ShadowBluetoothDevice shadowBluetoothDevice;
BluetoothDevice secondBluetoothDevice;
secondBluetoothDevice = mBluetoothAdapter.getRemoteDevice(TEST_DEVICE_ADDRESS_2);
- shadowBluetoothDevice = shadowOf(secondBluetoothDevice);
+ shadowBluetoothDevice = Shadows.shadowOf(secondBluetoothDevice);
shadowBluetoothDevice.setName(TEST_DEVICE_NAME_2);
mController.mConnectedDevices.clear();
mController.mConnectedDevices.add(mBluetoothDevice);
HelpMenuController.init(mHost);
- mHost.getLifecycle().onCreateOptionsMenu(null /* menu */, null /* inflater */);
+ mHost.getSettingsLifecycle().onCreateOptionsMenu(null /* menu */, null /* inflater */);
verify(mContext).getString(123);
}
public void onCreateOptionsMenu_noArgumentOverride_shouldPrepareHelpUsingProvider() {
HelpMenuController.init(mHost);
- mHost.getLifecycle().onCreateOptionsMenu(null /* menu */, null /* inflater */);
+ mHost.getSettingsLifecycle().onCreateOptionsMenu(null /* menu */, null /* inflater */);
verify(mContext).getString(mHost.getHelpResource());
}
- private static class TestFragment
- extends ObservablePreferenceFragment
+ private static class TestFragment extends ObservablePreferenceFragment
implements HelpResourceProvider {
@Override
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.IntentFilter;
import java.util.ArrayList;
import java.util.HashMap;
+import androidx.fragment.app.FragmentActivity;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
@RunWith(SettingsRobolectricTestRunner.class)
when(mProvider.getSurveyExpirationDate(any(), any())).thenReturn(-1L);
// Pretend we are an activity that is starting up
- Activity temp = Robolectric.setupActivity(Activity.class);
+ FragmentActivity temp = Robolectric.setupActivity(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(temp);
SurveyMixin mixin = new SurveyMixin(mFragment, FAKE_KEY);
mixin.onResume();
when(mProvider.getSurveyExpirationDate(any(), any())).thenReturn(0L);
// Pretend we are an activity that is starting up
- Activity temp = Robolectric.setupActivity(Activity.class);
+ FragmentActivity temp = Robolectric.setupActivity(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(temp);
SurveyMixin mixin = new SurveyMixin(mFragment, FAKE_KEY);
mixin.onResume();
when(mProvider.getSurveyExpirationDate(any(), any())).thenReturn(-1L);
// Pretend we are an activity that starts and stops
- Activity temp = Robolectric.setupActivity(Activity.class);
+ FragmentActivity temp = Robolectric.setupActivity(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(temp);
when(mProvider.createAndRegisterReceiver(any())).thenReturn(mReceiver);
LocalBroadcastManager manager = LocalBroadcastManager.getInstance(temp);
when(mProvider.getSurveyExpirationDate(any(), any())).thenReturn(-1L);
// Pretend we are an activity that fails to create a receiver properly
- Activity temp = Robolectric.setupActivity(Activity.class);
+ FragmentActivity temp = Robolectric.setupActivity(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(temp);
SurveyMixin mixin = new SurveyMixin(mFragment, FAKE_KEY);
mixin.onPause();
--- /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;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.LinearLayout;
+
+import org.robolectric.android.controller.ActivityController;
+import org.robolectric.android.controller.ComponentController;
+import org.robolectric.util.ReflectionHelpers;
+
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+
+/**
+ * Controller class for driving fragment lifecycles, similar to {@link ActivityController}.
+ */
+// TODO(b/111195167) - Duplicated from org.robolectric.android.controller.FragmentController.
+@Deprecated
+public class FragmentController<F extends Fragment> extends
+ ComponentController<FragmentController<F>, F> {
+ private final F fragment;
+ private final ActivityController<? extends FragmentActivity> activityController;
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment) {
+ return of(fragment, FragmentControllerActivity.class, null, null);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment,
+ Class<? extends FragmentActivity> activityClass) {
+ return of(fragment, activityClass, null, null);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment, Intent intent) {
+ return new FragmentController<>(fragment, FragmentControllerActivity.class, intent);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment, Bundle arguments) {
+ return new FragmentController<>(fragment, FragmentControllerActivity.class, arguments);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment, Intent intent,
+ Bundle arguments) {
+ return new FragmentController<>(fragment, FragmentControllerActivity.class, intent,
+ arguments);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment,
+ Class<? extends FragmentActivity> activityClass, Intent intent) {
+ return new FragmentController<>(fragment, activityClass, intent);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment,
+ Class<? extends FragmentActivity> activityClass, Bundle arguments) {
+ return new FragmentController<>(fragment, activityClass, arguments);
+ }
+
+ public static <F extends Fragment> FragmentController<F> of(F fragment,
+ Class<? extends FragmentActivity> activityClass,
+ Intent intent, Bundle arguments) {
+ return new FragmentController<>(fragment, activityClass, intent, arguments);
+ }
+
+ private FragmentController(F fragment, Class<? extends FragmentActivity> activityClass,
+ Intent intent) {
+ this(fragment, activityClass, intent, null);
+ }
+
+ private FragmentController(F fragment, Class<? extends FragmentActivity> activityClass,
+ Bundle arguments) {
+ this(fragment, activityClass, null, arguments);
+ }
+
+ private FragmentController(F fragment, Class<? extends FragmentActivity> activityClass,
+ Intent intent, Bundle arguments) {
+ super(fragment, intent);
+ this.fragment = fragment;
+ if (arguments != null) {
+ this.fragment.setArguments(arguments);
+ }
+ this.activityController = ActivityController.of(
+ ReflectionHelpers.callConstructor(activityClass), intent);
+ }
+
+ /**
+ * Creates the activity with {@link Bundle} and adds the fragment to the view with ID {@code
+ * contentViewId}.
+ */
+ public FragmentController<F> create(final int contentViewId, final Bundle bundle) {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.create(
+ bundle).get().getSupportFragmentManager().beginTransaction().add(
+ contentViewId, fragment).commit();
+ }
+ });
+ return this;
+ }
+
+ /**
+ * Creates the activity with {@link Bundle} and adds the fragment to it. Note that the fragment
+ * will be added to the view with ID 1.
+ */
+ public FragmentController<F> create(Bundle bundle) {
+ return create(1, bundle);
+ }
+
+ @Override
+ public FragmentController<F> create() {
+ return create(null);
+ }
+
+ @Override
+ public FragmentController<F> destroy() {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.destroy();
+ }
+ });
+ return this;
+ }
+
+ public FragmentController<F> start() {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.start();
+ }
+ });
+ return this;
+ }
+
+ public FragmentController<F> resume() {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.resume();
+ }
+ });
+ return this;
+ }
+
+ public FragmentController<F> pause() {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.pause();
+ }
+ });
+ return this;
+ }
+
+ public FragmentController<F> visible() {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.visible();
+ }
+ });
+ return this;
+ }
+
+ public FragmentController<F> stop() {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.stop();
+ }
+ });
+ return this;
+ }
+
+ public FragmentController<F> saveInstanceState(final Bundle outState) {
+ shadowMainLooper.runPaused(new Runnable() {
+ @Override
+ public void run() {
+ activityController.saveInstanceState(outState);
+ }
+ });
+ return this;
+ }
+
+ private static class FragmentControllerActivity extends FragmentActivity {
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ LinearLayout view = new LinearLayout(this);
+ view.setId(1);
+
+ setContentView(view);
+ }
+ }
+}
--- /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;
+
+
+import android.app.IntentService;
+import android.app.Service;
+import android.app.backup.BackupAgent;
+import android.content.ContentProvider;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.view.View;
+
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.android.XmlResourceParserImpl;
+import org.robolectric.android.controller.ActivityController;
+import org.robolectric.android.controller.BackupAgentController;
+import org.robolectric.android.controller.ContentProviderController;
+import org.robolectric.android.controller.IntentServiceController;
+import org.robolectric.android.controller.ServiceController;
+import org.robolectric.res.ResName;
+import org.robolectric.res.ResourceTable;
+import org.robolectric.shadows.ShadowApplication;
+import org.robolectric.util.ReflectionHelpers;
+import org.robolectric.util.Scheduler;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+
+// TODO(b/111195450) - Duplicated from org.robolectric.Robolectric.
+@Deprecated
+public class Robolectric {
+
+ /**
+ * This method is internal and shouldn't be called by developers.
+ */
+ @Deprecated
+ public static void reset() {
+ // No-op- is now handled in the test runner. Users should not be calling this method anyway.
+ }
+
+ public static <T extends Service> ServiceController<T> buildService(Class<T> serviceClass) {
+ return buildService(serviceClass, null);
+ }
+
+ public static <T extends Service> ServiceController<T> buildService(Class<T> serviceClass,
+ Intent intent) {
+ return ServiceController.of(ReflectionHelpers.callConstructor(serviceClass), intent);
+ }
+
+ public static <T extends Service> T setupService(Class<T> serviceClass) {
+ return buildService(serviceClass).create().get();
+ }
+
+ public static <T extends IntentService> IntentServiceController<T> buildIntentService(
+ Class<T> serviceClass) {
+ return buildIntentService(serviceClass, null);
+ }
+
+ public static <T extends IntentService> IntentServiceController<T> buildIntentService(
+ Class<T> serviceClass, Intent intent) {
+ return IntentServiceController.of(ReflectionHelpers.callConstructor(serviceClass,
+ new ReflectionHelpers.ClassParameter<String>(String.class, "IntentService")),
+ intent);
+ }
+
+ public static <T extends IntentService> T setupIntentService(Class<T> serviceClass) {
+ return buildIntentService(serviceClass).create().get();
+ }
+
+ public static <T extends ContentProvider> ContentProviderController<T> buildContentProvider(
+ Class<T> contentProviderClass) {
+ return ContentProviderController.of(
+ ReflectionHelpers.callConstructor(contentProviderClass));
+ }
+
+ public static <T extends ContentProvider> T setupContentProvider(
+ Class<T> contentProviderClass) {
+ return buildContentProvider(contentProviderClass).create().get();
+ }
+
+ public static <T extends ContentProvider> T setupContentProvider(Class<T> contentProviderClass,
+ String authority) {
+ return buildContentProvider(contentProviderClass).create(authority).get();
+ }
+
+ public static <T extends FragmentActivity> ActivityController<T> buildActivity(
+ Class<T> activityClass) {
+ return buildActivity(activityClass, null);
+ }
+
+ public static <T extends FragmentActivity> ActivityController<T> buildActivity(
+ Class<T> activityClass, Intent intent) {
+ return ActivityController.of(ReflectionHelpers.callConstructor(activityClass), intent);
+ }
+
+ public static <T extends FragmentActivity> T setupActivity(Class<T> activityClass) {
+ return buildActivity(activityClass).setup().get();
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass));
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Bundle arguments) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass), arguments);
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Class<? extends FragmentActivity> activityClass) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass),
+ activityClass);
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Intent intent) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass), intent);
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Intent intent,
+ Bundle arguments) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass), intent,
+ arguments);
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Class<? extends FragmentActivity> activityClass,
+ Intent intent) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass),
+ activityClass, intent);
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Class<? extends FragmentActivity> activityClass,
+ Bundle arguments) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass),
+ activityClass, arguments);
+ }
+
+ public static <T extends Fragment> FragmentController<T> buildFragment(Class<T> fragmentClass,
+ Class<? extends FragmentActivity> activityClass,
+ Intent intent,
+ Bundle arguments) {
+ return FragmentController.of(ReflectionHelpers.callConstructor(fragmentClass),
+ activityClass, intent, arguments);
+ }
+
+ public static <T extends BackupAgent> BackupAgentController<T> buildBackupAgent(
+ Class<T> backupAgentClass) {
+ return BackupAgentController.of(ReflectionHelpers.callConstructor(backupAgentClass));
+ }
+
+ public static <T extends BackupAgent> T setupBackupAgent(Class<T> backupAgentClass) {
+ return buildBackupAgent(backupAgentClass).create().get();
+ }
+
+ /**
+ * Allows for the programatic creation of an {@link AttributeSet} useful for testing
+ * {@link View} classes without
+ * the need for creating XML snippets.
+ */
+ public static AttributeSetBuilder buildAttributeSet() {
+ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+ factory.setNamespaceAware(true);
+ factory.setIgnoringComments(true);
+ factory.setIgnoringElementContentWhitespace(true);
+ Document document;
+ try {
+ DocumentBuilder documentBuilder = factory.newDocumentBuilder();
+ document = documentBuilder.newDocument();
+ Element dummy = document.createElementNS("http://schemas.android.com/apk/res/" +
+ RuntimeEnvironment.application.getPackageName(), "dummy");
+ document.appendChild(dummy);
+ } catch (ParserConfigurationException e) {
+ throw new RuntimeException(e);
+ }
+ return new AttributeSetBuilder(document, RuntimeEnvironment.getCompileTimeResourceTable());
+ }
+
+ public static class AttributeSetBuilder {
+
+ private Document doc;
+ private ResourceTable appResourceTable;
+
+ AttributeSetBuilder(Document doc, ResourceTable resourceTable) {
+ this.doc = doc;
+ this.appResourceTable = resourceTable;
+ }
+
+ public AttributeSetBuilder addAttribute(int resId, String value) {
+ ResName resName = appResourceTable.getResName(resId);
+ if ("style".equals(resName.name)) {
+ ((Element) doc.getFirstChild()).setAttribute(resName.name, value);
+ } else {
+ ((Element) doc.getFirstChild()).setAttributeNS(resName.getNamespaceUri(),
+ resName.packageName + ":" + resName.name, value);
+ }
+ return this;
+ }
+
+ public AttributeSetBuilder setStyleAttribute(String value) {
+ ((Element) doc.getFirstChild()).setAttribute("style", value);
+ return this;
+ }
+
+ public AttributeSet build() {
+ XmlResourceParserImpl parser = new XmlResourceParserImpl(doc, null,
+ RuntimeEnvironment.application.getPackageName(),
+ RuntimeEnvironment.application.getPackageName(), appResourceTable);
+ try {
+ parser.next(); // Root document element
+ parser.next(); // "dummy" element
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Expected single dummy element in the document to contain the attributes.",
+ e);
+ }
+
+ return parser;
+ }
+ }
+
+ /**
+ * Return the foreground scheduler (e.g. the UI thread scheduler).
+ *
+ * @return Foreground scheduler.
+ */
+ public static Scheduler getForegroundThreadScheduler() {
+ return ShadowApplication.getInstance().getForegroundThreadScheduler();
+ }
+
+ /**
+ * Execute all runnables that have been enqueued on the foreground scheduler.
+ */
+ public static void flushForegroundThreadScheduler() {
+ getForegroundThreadScheduler().advanceToLastPostedRunnable();
+ }
+
+ /**
+ * Return the background scheduler.
+ *
+ * @return Background scheduler.
+ */
+ public static Scheduler getBackgroundThreadScheduler() {
+ return ShadowApplication.getInstance().getBackgroundThreadScheduler();
+ }
+
+ /**
+ * Execute all runnables that have been enqueued on the background scheduler.
+ */
+ public static void flushBackgroundThreadScheduler() {
+ getBackgroundThreadScheduler().advanceToLastPostedRunnable();
+ }
+}
+
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;
@RealObject
Theme realTheme;
- private ShadowAssetManager mAssetManager = shadowOf(
+ private ShadowAssetManager mAssetManager = Shadows.shadowOf(
RuntimeEnvironment.application.getAssets());
@Implementation
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.pm.UserInfo;
import com.android.settings.R;
import com.android.settings.dashboard.SummaryLoader;
+import com.android.settings.testutils.Robolectric;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.RestrictedPreference;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.util.ReflectionHelpers;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceGroup;
@Mock
private SummaryLoader mSummaryLoader;
- private Activity mActivity;
+ private FragmentActivity mActivity;
private Context mContext;
private UserSettings mFragment;
private UserCapabilities mUserCapabilities;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mActivity = spy(Robolectric.buildActivity(Activity.class).get());
+ mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get());
mContext = spy(RuntimeEnvironment.application);
mFragment = spy(new UserSettings());
ReflectionHelpers.setField(mFragment, "mAddUserWhenLockedPreferenceController",
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
import org.robolectric.android.controller.ActivityController;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.Implementation;
@Test
public void launch_primarySuggestionActivityDoesNotExist_shouldFallback() {
ShadowPackageManager packageManager =
- shadowOf(RuntimeEnvironment.application.getPackageManager());
+ Shadows.shadowOf(RuntimeEnvironment.application.getPackageManager());
packageManager.removePackage("com.android.settings");
- ShadowActivity activity = shadowOf(mController.setup().get());
+ ShadowActivity activity = Shadows.shadowOf(mController.setup().get());
final Intent intent = activity.getNextStartedActivity();
assertThat(intent.getComponent().getClassName()).isEqualTo(SubSettings.class.getName());
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.ApplicationInfo;
import java.util.Arrays;
import java.util.Collections;
+import androidx.fragment.app.FragmentActivity;
+
@RunWith(SettingsRobolectricTestRunner.class)
public class WebViewAppPickerTest {
private UserInfo mSecondUser;
@Mock
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private UserManager mUserManager;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
import static org.mockito.Mockito.when;
import android.app.ActionBar;
-import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import org.robolectric.annotation.Config;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
import androidx.preference.Preference;
@RunWith(SettingsRobolectricTestRunner.class)
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
- private Activity mActivity;
+ private FragmentActivity mActivity;
@Mock
private Fragment mFragment;
public void bindButton_noAppInfo_shouldNotAttachClickListener() {
final View appLinks =
mLayoutInflater.inflate(R.layout.settings_entity_header, null /* root */);
- final Activity activity = mock(Activity.class);
+ final FragmentActivity activity = mock(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(activity);
mController = EntityHeaderController.newInstance(mActivity, mFragment, appLinks);
public void bindButton_hasAppInfo_shouldAttachClickListener() {
final View appLinks =
mLayoutInflater.inflate(R.layout.settings_entity_header, null /* root */);
- final Activity activity = mock(Activity.class);
+ final FragmentActivity activity = mock(FragmentActivity.class);
when(mFragment.getActivity()).thenReturn(activity);
when(mContext.getString(eq(R.string.application_info_label))).thenReturn("App Info");
public void iconContentDescription_shouldWorkWithSetIcon() {
final View view =
mLayoutInflater.inflate(R.layout.settings_entity_header, null /* root */);
- when(mFragment.getActivity()).thenReturn(mock(Activity.class));
+ when(mFragment.getActivity()).thenReturn(mock(FragmentActivity.class));
mController = EntityHeaderController.newInstance(mActivity, mFragment, view);
String description = "Fake Description";
mController.setIcon(mShadowContext.getDrawable(R.drawable.ic_add));
public void iconContentDescription_shouldWorkWithoutSetIcon() {
final View view = mLayoutInflater
.inflate(R.layout.settings_entity_header, null /* root */);
- when(mFragment.getActivity()).thenReturn(mock(Activity.class));
+ when(mFragment.getActivity()).thenReturn(mock(FragmentActivity.class));
mController = EntityHeaderController.newInstance(mActivity, mFragment, view);
String description = "Fake Description";
mController.setIconContentDescription(description);
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
+import org.robolectric.Shadows;
import org.robolectric.shadows.ShadowView;
@RunWith(SettingsRobolectricTestRunner.class)
@Test
public void requestRectangleOnScreen_withParent_shouldScrollToParent() {
- ShadowView shadowEditText = shadowOf(mEditText);
+ ShadowView shadowEditText = Shadows.shadowOf(mEditText);
shadowEditText.setMyParent(mParent);
assertThat(mEditText.requestRectangleOnScreen(
when(mActivity.getApplicationContext()).thenReturn(mActivity);
when(mActivity.getSystemService(Context.INPUT_METHOD_SERVICE))
.thenReturn(ReflectionHelpers.newInstance(InputMethodManager.class));
-
mWriteWifiConfigToNfcDialog = new WriteWifiConfigToNfcDialog(RuntimeEnvironment.application,
0 /* security */);
ReflectionHelpers.setField(mWriteWifiConfigToNfcDialog, "mWifiManager", mWifiManager);
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import java.util.Arrays;
import java.util.stream.Collectors;
+import androidx.fragment.app.FragmentActivity;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.PreferenceCategory;
import androidx.preference.PreferenceScreen;
@Mock
private AccessPoint mockAccessPoint;
@Mock
- private Activity mockActivity;
+ private FragmentActivity mockActivity;
@Mock
private ConnectivityManager mockConnectivityManager;
@Mock
import static com.google.common.truth.Truth.assertThat;
-import android.app.Activity;
import android.app.Instrumentation;
import android.content.Context;
import android.content.Intent;
import java.util.List;
import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
@RunWith(AndroidJUnit4.class)
@SmallTest
public void rotate_shouldSaveCategoriesChangedState() {
final Intent intent = new Intent(Settings.ACTION_SETTINGS)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- final Activity activity = mInstrumentation.startActivitySync(intent);
+ final FragmentActivity activity =
+ (FragmentActivity) mInstrumentation.startActivitySync(intent);
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
.text("Network & internet")), TIMEOUT);
assertThat(item).isNotNull();
- final List<Fragment> fragments = activity.getFragmentManager().getFragments();
+ final List<Fragment> fragments = activity.getSupportFragmentManager().getFragments();
final DashboardSummary fragment = (DashboardSummary) fragments.get(0);
assertThat(fragment.mIsOnCategoriesChangedCalled).isTrue();
import static android.support.test.espresso.matcher.ViewMatchers.withEffectiveVisibility;
import static android.support.test.espresso.matcher.ViewMatchers.withId;
import static android.support.test.espresso.matcher.ViewMatchers.withText;
+import static com.google.common.truth.Truth.assertThat;
import static org.hamcrest.CoreMatchers.not;
import android.support.test.espresso.action.ViewActions;
resourceString(WIFI_DISPLAY_STATUS_CONNECTED));
when(mWifiTracker.getAccessPoints()).thenReturn(
- Lists.asList(accessPoint, new AccessPoint[]{}));
+ Lists.asList(accessPoint, new AccessPoint[] {}));
}
/** Launch the activity via an Intent with a String extra. */
verify(mWifiTracker).getManager();
- List<Fragment> fragments = mActivityRule.getActivity().getFragmentManager().getFragments();
+ List<Fragment> fragments =
+ mActivityRule.getActivity().getSupportFragmentManager().getFragments();
assertThat(fragments.size()).isEqualTo(1);
mWifiListener = (WifiSettings) fragments.get(0);
assertThat(mWifiListener).isNotNull();
OSDN Git Service
