# Include the testing libraries (JUnit4 + Robolectric libs).
LOCAL_STATIC_JAVA_LIBRARIES := \
- platform-system-robolectric \
+ mockito-robolectric-prebuilt \
truth-prebuilt
LOCAL_JAVA_LIBRARIES := \
package com.android.settings;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.doReturn;
+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 android.app.Activity;
import android.app.ActivityManager;
import android.app.FragmentManager;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
-
import android.os.Bundle;
import android.view.Menu;
+
import com.android.settings.testutils.FakeFeatureFactory;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class SettingsActivityTest {
public void testSetTaskDescription_IconChanged() {
mActivity.setTaskDescription(mTaskDescription);
- verify(mTaskDescription).setIcon(any());
+ verify(mTaskDescription).setIcon(nullable(Bitmap.class));
}
@Test
mActivity.mDisplaySearch = true;
mActivity.onCreateOptionsMenu(null);
- verify(mFeatureFactory.getSearchFeatureProvider()).setUpSearchMenu(any(Menu.class),
- any(Activity.class));
+ verify(mFeatureFactory.getSearchFeatureProvider()).setUpSearchMenu(nullable(Menu.class),
+ nullable(Activity.class));
}
@Test
*/
package com.android.settings.accounts;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Answers.RETURNS_DEEP_STUBS;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AuthenticatorDescription;
import java.util.ArrayList;
import java.util.List;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Answers.RETURNS_DEEP_STUBS;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION,
shadows = {ShadowAccountManager.class, ShadowContentResolver.class})
mController.onResume();
// each account should be added only once
- verify(preferenceGroup).addPreference(argThat(new PreferenceMatcher("Acct11")));
- verify(preferenceGroup).addPreference(argThat(new PreferenceMatcher("Acct12")));
+ verify(preferenceGroup).addPreference(argThat(titleMatches("Acct11")));
+ verify(preferenceGroup).addPreference(argThat(titleMatches("Acct12")));
}
@Test
mController.onResume();
// each account should be added only once
- verify(preferenceGroup, times(1)).addPreference(argThat(new PreferenceMatcher("Acct11")));
- verify(preferenceGroup, times(1)).addPreference(argThat(new PreferenceMatcher("Acct12")));
- verify(preferenceGroup, times(1)).addPreference(argThat(new PreferenceMatcher("Acct13")));
+ verify(preferenceGroup, times(1)).addPreference(argThat(titleMatches("Acct11")));
+ verify(preferenceGroup, times(1)).addPreference(argThat(titleMatches("Acct12")));
+ verify(preferenceGroup, times(1)).addPreference(argThat(titleMatches("Acct13")));
}
@Test
// Resume should show the newly added account
mController.onResume();
- verify(preferenceGroup).addPreference(argThat(new PreferenceMatcher("Acct1")));
+ verify(preferenceGroup).addPreference(argThat(titleMatches("Acct1")));
}
@Test
mController.onResume();
- verify(preferenceGroup, times(1)).addPreference(argThat(new PreferenceMatcher("Acct11")));
- verify(preferenceGroup, times(1)).addPreference(argThat(new PreferenceMatcher("Acct12")));
- verify(preferenceGroup, times(1)).removePreference(
- argThat(new PreferenceMatcher("Acct12")));
+ verify(preferenceGroup, times(1)).addPreference(argThat(titleMatches("Acct11")));
+ verify(preferenceGroup, times(1)).addPreference(argThat(titleMatches("Acct12")));
+ verify(preferenceGroup, times(1)).removePreference(argThat(titleMatches("Acct12")));
}
- private static class PreferenceMatcher extends ArgumentMatcher<Preference> {
-
- private final String mExpectedTitle;
-
- public PreferenceMatcher(String title) {
- mExpectedTitle = title;
- }
-
- @Override
- public boolean matches(Object arg) {
- final Preference preference = (Preference) arg;
- return TextUtils.equals(mExpectedTitle, preference.getTitle());
- }
+ private static ArgumentMatcher<Preference> titleMatches(String expected) {
+ return preference -> TextUtils.equals(expected, preference.getTitle());
}
-
}
*/
package com.android.settings.accounts;
+import static org.mockito.Answers.RETURNS_DEEP_STUBS;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+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 android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AccountManagerCallback;
import android.os.Bundle;
import android.os.Handler;
import android.os.UserHandle;
-import android.support.v7.preference.PreferenceScreen;
import android.support.v14.preference.PreferenceFragment;
+import android.support.v7.preference.PreferenceScreen;
import android.widget.Button;
-import com.android.settings.AccessiblePreferenceCategory;
import com.android.settings.R;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.LayoutPreference;
-import com.android.settings.search.SearchIndexableRaw;
-import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.shadow.ShadowAccountManager;
import com.android.settings.testutils.shadow.ShadowContentResolver;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Answers.RETURNS_DEEP_STUBS;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class RemoveAccountPreferenceControllerTest {
mFragment, account, userHandle);
dialog.onCreate(new Bundle());
dialog.onClick(null, 0);
- verify(mAccountManager).removeAccountAsUser(eq(account), any(Activity.class),
- any(AccountManagerCallback.class), any(Handler.class), eq(userHandle));
+ verify(mAccountManager).removeAccountAsUser(eq(account), nullable(Activity.class),
+ nullable(AccountManagerCallback.class), nullable(Handler.class), eq(userHandle));
}
}
\ No newline at end of file
package com.android.settings.applications;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Matchers.nullable;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class DrawOverlayDetailsTest {
public void logSpecialPermissionChange() {
mFragment.onAttach(ShadowApplication.getInstance().getApplicationContext());
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_APPDRAW_ALLOW), eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_APPDRAW_DENY), eq("app"));
}
import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
when(stats.getCodeBytes()).thenReturn(1L);
when(stats.getDataBytes()).thenReturn(2L);
when(stats.getCacheBytes()).thenReturn(3L);
- when(mSource.getStatsForPackage(anyString(), anyString(), any(UserHandle.class)))
+ when(mSource.getStatsForPackage(nullable(String.class), nullable(String.class),
+ any(UserHandle.class)))
.thenReturn(stats);
ApplicationInfo info = new ApplicationInfo();
info.packageName = PACKAGE_NAME;
package com.android.settings.applications;
+import static com.android.settings.testutils.ApplicationTestUtils.buildInfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.UserInfo;
-import android.os.Build;
import android.os.UserHandle;
import android.os.UserManager;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.List;
+import java.util.Collections;
import java.util.Set;
-import static com.android.settings.testutils.ApplicationTestUtils.buildInfo;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
/**
* Tests for {@link InstalledAppCounter}.
*/
private void expectQueryIntentActivities(int userId, String packageName, boolean launchable) {
when(mPackageManager.queryIntentActivitiesAsUser(
- argThat(new IsLaunchIntentFor(packageName)),
+ argThat(isLaunchIntentFor(packageName)),
eq(PackageManager.GET_DISABLED_COMPONENTS | PackageManager.MATCH_DIRECT_BOOT_AWARE
| PackageManager.MATCH_DIRECT_BOOT_UNAWARE),
- eq(userId))).thenReturn(launchable ? Arrays.asList(new ResolveInfo())
- : new ArrayList<ResolveInfo>());
+ eq(userId))).thenReturn(launchable
+ ? Collections.singletonList(new ResolveInfo())
+ : new ArrayList<>());
}
private void testCountInstalledAppsAcrossAllUsers(boolean async) {
verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MAIN_USER_ID));
verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(),
eq(MANAGED_PROFILE_ID));
- verify(mPackageManager, atLeast(0)).queryIntentActivitiesAsUser(anyObject(), anyInt(),
+ verify(mPackageManager, atLeast(0)).queryIntentActivitiesAsUser(any(Intent.class), anyInt(),
anyInt());
verifyNoMoreInteractions(mPackageManager);
}
}
- private static class IsLaunchIntentFor extends ArgumentMatcher<Intent> {
- private final String mPackageName;
-
- IsLaunchIntentFor(String packageName) {
- mPackageName = packageName;
- }
-
- @Override
- public boolean matches(Object i) {
- final Intent intent = (Intent) i;
+ private ArgumentMatcher<Intent> isLaunchIntentFor(String packageName) {
+ return intent -> {
if (intent == null) {
return false;
}
!categories.contains(Intent.CATEGORY_LAUNCHER)) {
return false;
}
- if (!mPackageName.equals(intent.getPackage())) {
+ if (!packageName.equals(intent.getPackage())) {
return false;
}
return true;
- }
+ };
}
}
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyDouble;
import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;
import android.app.AlertDialog;
+import android.app.Fragment;
import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.content.Intent;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.instantapps.InstantAppButtonsController;
+import com.android.settings.applications.instantapps.InstantAppButtonsController.ShowDialogDelegate;
import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settingslib.applications.AppUtils;
@Test
public void shouldShowUninstallForAll_installForOneOtherUserOnly_shouldReturnTrue() {
- when(mDevicePolicyManager.packageHasActiveAdmins(anyString())).thenReturn(false);
+ when(mDevicePolicyManager.packageHasActiveAdmins(nullable(String.class))).thenReturn(false);
when(mUserManager.getUsers().size()).thenReturn(2);
ReflectionHelpers.setField(mAppDetail, "mDpm", mDevicePolicyManager);
ReflectionHelpers.setField(mAppDetail, "mUserManager", mUserManager);
@Test
public void shouldShowUninstallForAll_installForSelfOnly_shouldReturnFalse() {
- when(mDevicePolicyManager.packageHasActiveAdmins(anyString())).thenReturn(false);
+ when(mDevicePolicyManager.packageHasActiveAdmins(nullable(String.class))).thenReturn(false);
when(mUserManager.getUsers().size()).thenReturn(2);
ReflectionHelpers.setField(mAppDetail, "mDpm", mDevicePolicyManager);
ReflectionHelpers.setField(mAppDetail, "mUserManager", mUserManager);
// Make this app appear to be instant.
ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
(InstantAppDataProvider) (i -> true));
- when(mDevicePolicyManager.packageHasActiveAdmins(anyString())).thenReturn(false);
+ when(mDevicePolicyManager.packageHasActiveAdmins(nullable(String.class))).thenReturn(false);
when(mUserManager.getUsers().size()).thenReturn(2);
final ApplicationInfo info = new ApplicationInfo();
final InstantAppButtonsController buttonsController =
mock(InstantAppButtonsController.class);
- when(buttonsController.setPackageName(anyString())).thenReturn(buttonsController);
+ when(buttonsController.setPackageName(nullable(String.class)))
+ .thenReturn(buttonsController);
FakeFeatureFactory.setupForTest(mContext);
FakeFeatureFactory factory =
(FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
when(factory.applicationFeatureProvider.newInstantAppButtonsController(
- any(), any(), any())).thenReturn(buttonsController);
+ nullable(Fragment.class), nullable(View.class), nullable(ShowDialogDelegate.class)))
+ .thenReturn(buttonsController);
fragment.maybeAddInstantAppButtons();
- verify(buttonsController).setPackageName(anyString());
+ verify(buttonsController).setPackageName(nullable(String.class));
verify(buttonsController).show();
}
private void expectQueryIntentActivities(int userId, String packageName, boolean launchable) {
when(mPackageManager.queryIntentActivitiesAsUser(
- argThat(new IsLaunchIntentFor(packageName)),
+ argThat(isLaunchIntentFor(packageName)),
eq(PackageManager.GET_DISABLED_COMPONENTS | PackageManager.MATCH_DIRECT_BOOT_AWARE
| PackageManager.MATCH_DIRECT_BOOT_UNAWARE),
- eq(userId))).thenReturn(launchable ? Arrays.asList(new ResolveInfo())
- : new ArrayList<ResolveInfo>());
+ eq(userId))).thenReturn(launchable
+ ? Collections.singletonList(new ResolveInfo())
+ : Collections.emptyList());
}
@Test
}
}
- private static class IsLaunchIntentFor extends ArgumentMatcher<Intent> {
- private final String mPackageName;
-
- IsLaunchIntentFor(String packageName) {
- mPackageName = packageName;
- }
-
- @Override
- public boolean matches(Object i) {
- final Intent intent = (Intent) i;
+ private static ArgumentMatcher<Intent> isLaunchIntentFor(String packageName) {
+ return intent -> {
if (intent == null) {
return false;
}
!categories.contains(Intent.CATEGORY_LAUNCHER)) {
return false;
}
- if (!mPackageName.equals(intent.getPackage())) {
+ if (!packageName.equals(intent.getPackage())) {
return false;
}
return true;
- }
+ };
}
}
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.nullable;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
-import com.android.settingslib.deviceinfo.StorageVolumeProvider;
import com.android.settingslib.applications.StorageStatsSource;
+import com.android.settingslib.deviceinfo.StorageVolumeProvider;
import org.junit.Before;
import org.junit.Test;
@Test
public void storageShouldRepresentStorageStatsQuery() throws Exception {
- when(mSource.getExternalStorageStats(any(String.class), any(UserHandle.class))).thenReturn(
+ when(mSource.getExternalStorageStats(nullable(String.class), nullable(UserHandle.class))).thenReturn(
new StorageStatsSource.ExternalStorageStats(1, 1, 0, 0));
mController.queryStats();
package com.android.settings.applications;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import org.robolectric.util.ReflectionHelpers;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
@Test
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_PICTURE_IN_PICTURE_ALLOW), eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_PICTURE_IN_PICTURE_DENY), eq("app"));
}
package com.android.settings.applications;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class PremiumSmsAccessTest {
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(SmsUsageMonitor.PREMIUM_SMS_PERMISSION_ASK_USER,
"app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_ASK), eq("app"));
mFragment.logSpecialPermissionChange(SmsUsageMonitor.PREMIUM_SMS_PERMISSION_NEVER_ALLOW,
"app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_DENY), eq("app"));
mFragment.logSpecialPermissionChange(SmsUsageMonitor.PREMIUM_SMS_PERMISSION_ALWAYS_ALLOW,
"app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_ALWAYS_ALLOW),
eq("app"));
}
package com.android.settings.applications;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class UsageAccessDetailsTest {
@Test
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_ALLOW), eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_DENY), eq("app"));
}
}
package com.android.settings.applications;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class VrListenerSettingsTest {
@Test
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_VRHELPER_ALLOW), eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_VRHELPER_DENY), eq("app"));
}
}
package com.android.settings.applications;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class WriteSettingsDetailsTest {
@Test
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_ALLOW),
eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_DENY),
eq("app"));
}
*/
package com.android.settings.core.instrumentation;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent
+ .FIELD_SETTINGS_PREFERENCE_CHANGE_FLOAT_VALUE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent
+ .FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent
+ .FIELD_SETTINGS_PREFERENCE_CHANGE_NAME;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import android.content.SharedPreferences;
import android.util.Pair;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static com.android.internal.logging.nano.MetricsProto.MetricsEvent
- .FIELD_SETTINGS_PREFERENCE_CHANGE_FLOAT_VALUE;
-import static com.android.internal.logging.nano.MetricsProto.MetricsEvent
- .FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE;
-import static com.android.internal.logging.nano.MetricsProto.MetricsEvent
- .FIELD_SETTINGS_PREFERENCE_CHANGE_NAME;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class SharedPreferenceLoggerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
- private PairMatcher mNamePairMatcher;
+ private ArgumentMatcher<Pair<Integer, Object>> mNamePairMatcher;
private FakeFeatureFactory mFactory;
private MetricsFeatureProvider mMetricsFeature;
private SharedPreferencesLogger mSharedPrefLogger;
mMetricsFeature = mFactory.metricsFeatureProvider;
mSharedPrefLogger = new SharedPreferencesLogger(mContext, TEST_TAG);
- mNamePairMatcher = new PairMatcher(FIELD_SETTINGS_PREFERENCE_CHANGE_NAME, String.class);
+ mNamePairMatcher = pairMatches(FIELD_SETTINGS_PREFERENCE_CHANGE_NAME, String.class);
}
@Test
editor.putInt(TEST_KEY, 2);
editor.putInt(TEST_KEY, 2);
- final PairMatcher longMatcher =
- new PairMatcher(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, Long.class);
-
verify(mMetricsFeature, times(6)).action(any(Context.class), anyInt(),
- argThat(mNamePairMatcher), argThat(longMatcher));
+ argThat(mNamePairMatcher),
+ argThat(pairMatches(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, Long.class)));
}
@Test
editor.putBoolean(TEST_KEY, false);
- final PairMatcher trueMatcher =
- new PairMatcher(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, true);
- final PairMatcher falseMatcher =
- new PairMatcher(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, false);
-
verify(mMetricsFeature).action(any(Context.class), anyInt(),
- argThat(mNamePairMatcher), argThat(trueMatcher));
+ argThat(mNamePairMatcher),
+ argThat(pairMatches(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, true)));
verify(mMetricsFeature, times(3)).action(any(Context.class), anyInt(),
- argThat(mNamePairMatcher), argThat(falseMatcher));
+ argThat(mNamePairMatcher),
+ argThat(pairMatches(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, false)));
}
@Test
editor.putLong(TEST_KEY, 1);
editor.putLong(TEST_KEY, 2);
- final PairMatcher longMatcher =
- new PairMatcher(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, Long.class);
-
verify(mMetricsFeature, times(4)).action(any(Context.class), anyInt(),
- argThat(mNamePairMatcher), argThat(longMatcher));
+ argThat(mNamePairMatcher),
+ argThat(pairMatches(FIELD_SETTINGS_PREFERENCE_CHANGE_LONG_VALUE, Long.class)));
}
@Test
editor.putFloat(TEST_KEY, 1);
editor.putFloat(TEST_KEY, 2);
- final PairMatcher floatMatcher =
- new PairMatcher(FIELD_SETTINGS_PREFERENCE_CHANGE_FLOAT_VALUE, Float.class);
-
verify(mMetricsFeature, times(4)).action(any(Context.class), anyInt(),
- argThat(mNamePairMatcher), argThat(floatMatcher));
+ argThat(mNamePairMatcher),
+ argThat(pairMatches(FIELD_SETTINGS_PREFERENCE_CHANGE_FLOAT_VALUE, Float.class)));
+ }
+
+ private ArgumentMatcher<Pair<Integer, Object>> pairMatches(int tag, Class clazz) {
+ return pair -> pair.first == tag && Platform.isInstanceOfType(pair.second, clazz);
}
- private static class PairMatcher extends ArgumentMatcher<Pair<Integer, Object>> {
-
- private final int mExpectedTag;
- private final Class mExpectedClass;
- private final Long mExpectedBoolean;
-
-
- public PairMatcher(int tag, Class clazz) {
- mExpectedTag = tag;
- mExpectedClass = clazz;
- mExpectedBoolean = null;
- }
-
- public PairMatcher(int tag, boolean bool) {
- mExpectedTag = tag;
- mExpectedClass = Long.class;
- mExpectedBoolean = bool ? 1L : 0L;
- }
-
- @Override
- public boolean matches(Object arg) {
- final Pair<Integer, Object> pair = (Pair) arg;
- boolean booleanMatch = mExpectedBoolean == null
- || mExpectedBoolean == pair.second;
- return pair.first == mExpectedTag
- && Platform.isInstanceOfType(pair.second, mExpectedClass)
- && booleanMatch;
- }
+ private ArgumentMatcher<Pair<Integer, Object>> pairMatches(int tag, boolean bool) {
+ return pair ->
+ pair.first == tag
+ && Platform.isInstanceOfType(pair.second, Long.class)
+ && pair.second.equals((bool ? 1L : 0L));
}
}
*/
package com.android.settings.core.instrumentation;
+import static com.android.settings.core.instrumentation.Instrumentable.METRICS_CATEGORY_UNKNOWN;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+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 org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static com.android.settings.core.instrumentation.Instrumentable.METRICS_CATEGORY_UNKNOWN;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
mMixin.onResume();
verify(mMetricsFeature, times(1))
- .visible(any(Context.class), eq(MetricsProto.MetricsEvent.VIEW_UNKNOWN),
+ .visible(nullable(Context.class), eq(MetricsProto.MetricsEvent.VIEW_UNKNOWN),
eq(TestInstrumentable.TEST_METRIC));
}
mMixin.onResume();
verify(mMetricsFeature, times(1))
- .visible(any(Context.class), eq(MetricsProto.MetricsEvent.SETTINGS_GESTURES),
+ .visible(nullable(Context.class), eq(MetricsProto.MetricsEvent.SETTINGS_GESTURES),
eq(TestInstrumentable.TEST_METRIC));
}
mMixin.onPause();
verify(mMetricsFeature, times(1))
- .hidden(any(Context.class), eq(TestInstrumentable.TEST_METRIC));
+ .hidden(nullable(Context.class), eq(TestInstrumentable.TEST_METRIC));
}
@Test
mMixin.onPause();
verify(mMetricsFeature, never())
- .hidden(any(Context.class), anyInt());
+ .hidden(nullable(Context.class), anyInt());
}
@Test
mMixin.onPause();
verify(mMetricsFeature, never())
- .hidden(any(Context.class), anyInt());
+ .hidden(nullable(Context.class), anyInt());
}
private final class TestInstrumentable implements Instrumentable {
*/
package com.android.settings.dashboard;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
import android.os.Bundle;
import android.support.v7.preference.Preference;
import java.util.ArrayList;
import java.util.List;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class DashboardFragmentTest {
mDashboardCategory.tiles.add(new Tile());
mTestFragment = new TestFragment(ShadowApplication.getInstance().getApplicationContext());
when(mFakeFeatureFactory.dashboardFeatureProvider.getProgressiveDisclosureMixin(
- any(Context.class), eq(mTestFragment), any(Bundle.class)))
+ nullable(Context.class), eq(mTestFragment), nullable(Bundle.class)))
.thenReturn(mDisclosureMixin);
- when(mFakeFeatureFactory.dashboardFeatureProvider.getTilesForCategory(anyString()))
+ when(mFakeFeatureFactory.dashboardFeatureProvider
+ .getTilesForCategory(nullable(String.class)))
.thenReturn(mDashboardCategory);
mTestFragment.onAttach(ShadowApplication.getInstance().getApplicationContext());
when(mContext.getPackageName()).thenReturn("TestPackage");
@Test
public void displayTilesAsPreference_shouldAddTilesWithIntent() {
- when(mFakeFeatureFactory.dashboardFeatureProvider.getTilesForCategory(anyString()))
+ when(mFakeFeatureFactory.dashboardFeatureProvider
+ .getTilesForCategory(nullable(String.class)))
.thenReturn(mDashboardCategory);
- when(mFakeFeatureFactory.dashboardFeatureProvider.getDashboardKeyForTile(any(Tile.class)))
+ when(mFakeFeatureFactory.dashboardFeatureProvider
+ .getDashboardKeyForTile(nullable(Tile.class)))
.thenReturn("test_key");
mTestFragment.onCreatePreferences(new Bundle(), "rootKey");
- verify(mDisclosureMixin).addPreference(any(PreferenceScreen.class),
- any(Preference.class));
+ verify(mDisclosureMixin).addPreference(nullable(PreferenceScreen.class),
+ nullable(Preference.class));
}
@Test
public void displayTilesAsPreference_shouldNotAddTilesWithoutIntent() {
mTestFragment.onCreatePreferences(new Bundle(), "rootKey");
- verify(mTestFragment.mScreen, never()).addPreference(any(Preference.class));
+ verify(mTestFragment.mScreen, never()).addPreference(nullable(Preference.class));
}
@Test
mDashboardCategory.tiles = null;
mTestFragment.onCreatePreferences(new Bundle(), "rootKey");
- verify(mTestFragment.mScreen, never()).addPreference(any(Preference.class));
+ verify(mTestFragment.mScreen, never()).addPreference(nullable(Preference.class));
}
@Test
import java.util.List;
import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
@Test
public void findPreference_prefInCollapsedList_shouldFindIt() {
- when(mScreen.findPreference(anyString())).thenReturn(null);
+ when(mScreen.findPreference(nullable(String.class))).thenReturn(null);
mMixin.addToCollapsedList(mPreference);
Preference pref = mMixin.findPreference(mScreen, mPreference.getKey());
@Test
public void findPreference_prefNotInCollapsedListOrScreen_shouldNotFindIt() {
- when(mScreen.findPreference(anyString())).thenReturn(null);
+ when(mScreen.findPreference(nullable(String.class))).thenReturn(null);
Preference pref = mMixin.findPreference(mScreen, mPreference.getKey());
assertThat(pref).isNull();
@Test
public void findPreference_prefRemovedFromCollapsedList_shouldNotFindIt() {
- when(mScreen.findPreference(anyString())).thenReturn(null);
+ when(mScreen.findPreference(nullable(String.class))).thenReturn(null);
mMixin.addToCollapsedList(mPreference);
mMixin.removePreference(mPreferenceFragment.getPreferenceScreen(), mPreference.getKey());
@Test
public void findPreference_nestedPrefInCollapsedList_shouldFindIt() {
- when(mScreen.findPreference(anyString())).thenReturn(null);
+ when(mScreen.findPreference(nullable(String.class))).thenReturn(null);
final PreferenceScreen prefGroup = spy(new PreferenceScreen(mAppContext, null));
when(prefGroup.getPreferenceManager()).thenReturn(mock(PreferenceManager.class));
final Preference preference = mock(Preference.class);
@Test
public void removeLastPreference_shouldRemoveExpandButtonToo() {
- when(mScreen.findPreference(anyString())).thenReturn(null);
+ when(mScreen.findPreference(nullable(String.class))).thenReturn(null);
mMixin.addToCollapsedList(mPreference);
// Collapsed
assertThat(mMixin.isCollapsed()).isTrue();
mMixin.collapse(screen);
assertThat(mMixin.isCollapsed()).isFalse();
- verify(mExpandButton, never()).setSummary(anyString());
+ verify(mExpandButton, never()).setSummary(nullable(String.class));
verify(screen, never()).addPreference(any(Preference.class));
verify(screen, never()).removePreference(any(Preference.class));
}
mMixin.collapse(screen);
assertThat(mMixin.isCollapsed()).isTrue();
- verify(mExpandButton, atLeastOnce()).setSummary(anyString());
+ verify(mExpandButton, atLeastOnce()).setSummary(nullable(String.class));
verify(screen).addPreference(any(ExpandPreference.class));
verify(screen, times(3)).removePreference(any(Preference.class));
}
lastPref.setOrder(100);
// Add something to collapsed list so we are in collapsed state.
mMixin.addToCollapsedList(new Preference(mAppContext));
- verify(mExpandButton).setSummary(anyString());
+ verify(mExpandButton).setSummary(nullable(String.class));
assertThat(mMixin.getCollapsedPrefs().size()).isEqualTo(1);
// 3 prefs on screen, 2 are real and the last one is more button.
lastPref.setOrder(100);
// Add something to collapsed list so we are in collapsed state.
mMixin.addToCollapsedList(new Preference(mAppContext));
- verify(mExpandButton).setSummary(anyString());
+ verify(mExpandButton).setSummary(nullable(String.class));
assertThat(mMixin.getCollapsedPrefs().size()).isEqualTo(1);
// 3 prefs on screen, 2 are real and the last one is more button.
verify(mScreen, never()).removePreference(any(Preference.class));
verify(mScreen, never()).addPreference(any(Preference.class));
- verify(mExpandButton, times(2)).setSummary(anyString());
+ verify(mExpandButton, times(2)).setSummary(nullable(String.class));
assertThat(mMixin.getCollapsedPrefs().get(0)).isSameAs(toBeAdded);
}
package com.android.settings.dashboard.suggestions;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.helper.ItemTouchHelper;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class SuggestionDismissControllerTest {
mController.onSwiped(vh, ItemTouchHelper.START);
verify(mFactory.suggestionsFeatureProvider).dismissSuggestion(
- eq(mContext), eq(mSuggestionParser), any(Tile.class));
- verify(mCallback).onSuggestionDismissed(any(Tile.class));
+ eq(mContext), eq(mSuggestionParser), nullable(Tile.class));
+ verify(mCallback).onSuggestionDismissed(nullable(Tile.class));
}
}
*/
package com.android.settings.datausage;
-import com.android.internal.logging.nano.MetricsProto;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.os.Process;
+
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settingslib.applications.ApplicationsState;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class UnrestrictedDataAccessTest {
@Test
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_UNL_DATA_ALLOW), eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_UNL_DATA_DENY), eq("app"));
}
package com.android.settings.datetime;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
import android.app.Activity;
import android.os.Bundle;
import android.view.LayoutInflater;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class ZonePickerTest {
// Should render
verify(mZonePicker).onCreateView(
- any(LayoutInflater.class),
- any(ViewGroup.class),
- any(Bundle.class));
+ nullable(LayoutInflater.class),
+ nullable(ViewGroup.class),
+ nullable(Bundle.class));
}
}
package com.android.settings.deviceinfo;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.app.Activity;
import android.app.usage.StorageStatsManager;
import android.icu.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class StorageSettingsTest {
when(volumeInfo.isMountedReadable()).thenReturn(true);
when(volumeInfo.getType()).thenReturn(VolumeInfo.TYPE_PRIVATE);
when(mStorageManagerVolumeProvider.getTotalBytes(
- any(StorageStatsManager.class), any(VolumeInfo.class)))
+ nullable(StorageStatsManager.class), nullable(VolumeInfo.class)))
.thenReturn(500L);
when(mStorageManagerVolumeProvider.getFreeBytes(
- any(StorageStatsManager.class), any(VolumeInfo.class)))
+ nullable(StorageStatsManager.class), nullable(VolumeInfo.class)))
.thenReturn(0L);
ReflectionHelpers.setField(
package com.android.settings.deviceinfo;
+import static org.mockito.Answers.RETURNS_DEEP_STUBS;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
-import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.hardware.usb.UsbManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static org.mockito.Answers.RETURNS_DEEP_STUBS;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class UsbBackendTest {
usbBackend.getCurrentMode();
verify(mContext).registerReceiver(eq(null),
- argThat(new ArgumentMatcher<IntentFilter>() {
- @Override
- public boolean matches(Object i) {
- final IntentFilter intentFilter = (IntentFilter) i;
- return intentFilter != null &&
- UsbManager.ACTION_USB_STATE.equals(intentFilter.getAction(0));
- }
- }));
+ argThat(intentFilter -> intentFilter != null &&
+ UsbManager.ACTION_USB_STATE.equals(intentFilter.getAction(0))));
}
}
package com.android.settings.deviceinfo.storage;
-import static com.google.common.truth.Truth.assertThat;
import static com.android.settings.utils.FileSizeFormatter.MEGABYTE_IN_BYTES;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
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 android.app.Fragment;
import android.content.Context;
import android.content.Intent;
final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mFragment.getActivity()).startActivityAsUser(argumentCaptor.capture(),
- any(UserHandle.class));
+ nullable(UserHandle.class));
Intent intent = argumentCaptor.getValue();
assertThat(intent.getType()).isEqualTo("image/*");
final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mFragment.getActivity()).startActivityAsUser(argumentCaptor.capture(),
- any(UserHandle.class));
+ nullable(UserHandle.class));
Intent intent = argumentCaptor.getValue();
assertThat(intent.getAction()).isEqualTo(Intent.ACTION_MAIN);
final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mFragment.getActivity()).startActivityAsUser(argumentCaptor.capture(),
- any(UserHandle.class));
+ nullable(UserHandle.class));
Intent intent = argumentCaptor.getValue();
assertThat(intent.getAction()).isEqualTo(Intent.ACTION_MAIN);
@Test
public void testClickFiles() {
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(mVolume);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(mVolume);
mPreference.setKey("pref_files");
mController.handlePreferenceTreeClick(mPreference);
final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mFragment.getActivity()).startActivityAsUser(argumentCaptor.capture(),
- any(UserHandle.class));
+ nullable(UserHandle.class));
Intent intent = argumentCaptor.getValue();
Intent browseIntent = mVolume.buildBrowseIntent();
assertThat(intent.getAction()).isEqualTo(browseIntent.getAction());
assertThat(intent.getData()).isEqualTo(browseIntent.getData());
verify(mMetricsFeatureProvider, times(1)).action(
- any(Context.class), eq(MetricsEvent.STORAGE_FILES));
+ nullable(Context.class), eq(MetricsEvent.STORAGE_FILES));
}
@Test
final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mFragment.getActivity()).startActivityAsUser(argumentCaptor.capture(),
- any(UserHandle.class));
+ nullable(UserHandle.class));
Intent intent = argumentCaptor.getValue();
assertThat(intent.getAction()).isEqualTo(Intent.ACTION_MAIN);
final ArgumentCaptor<Intent> argumentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mFragment.getActivity()).startActivityAsUser(argumentCaptor.capture(),
- any(UserHandle.class));
+ nullable(UserHandle.class));
Intent intent = argumentCaptor.getValue();
assertThat(intent.getAction()).isEqualTo(Intent.ACTION_MAIN);
assertThat(mController.handlePreferenceTreeClick(mPreference)).isTrue();
verify(mFragment.getFragmentManager().beginTransaction()).add(
- any(PrivateVolumeSettings.SystemInfoFragment.class), anyString());
+ nullable(PrivateVolumeSettings.SystemInfoFragment.class), nullable(String.class));
}
@Test
mController.setUserId(new UserHandle(10));
- verify(audio, times(2)).setIcon(any(Drawable.class));
- verify(video, times(2)).setIcon(any(Drawable.class));
- verify(image, times(2)).setIcon(any(Drawable.class));
- verify(games, times(2)).setIcon(any(Drawable.class));
- verify(apps, times(2)).setIcon(any(Drawable.class));
- verify(system, times(2)).setIcon(any(Drawable.class));
- verify(files, times(2)).setIcon(any(Drawable.class));
+ verify(audio, times(2)).setIcon(nullable(Drawable.class));
+ verify(video, times(2)).setIcon(nullable(Drawable.class));
+ verify(image, times(2)).setIcon(nullable(Drawable.class));
+ verify(games, times(2)).setIcon(nullable(Drawable.class));
+ verify(apps, times(2)).setIcon(nullable(Drawable.class));
+ verify(system, times(2)).setIcon(nullable(Drawable.class));
+ verify(files, times(2)).setIcon(nullable(Drawable.class));
}
@Test
when(screen.findPreference(eq(StorageItemPreferenceController.FILES_KEY)))
.thenReturn(files);
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(mVolume);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(mVolume);
when(mVolume.isMountedReadable()).thenReturn(true);
mController.displayPreference(screen);
when(screen.findPreference(eq(StorageItemPreferenceController.FILES_KEY)))
.thenReturn(files);
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(mVolume);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(mVolume);
when(mVolume.isMountedReadable()).thenReturn(false);
mController.displayPreference(screen);
when(screen.findPreference(eq(StorageItemPreferenceController.FILES_KEY)))
.thenReturn(files);
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(null);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(null);
mController.displayPreference(screen);
when(screen.findPreference(eq(StorageItemPreferenceController.FILES_KEY)))
.thenReturn(files);
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(mVolume);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(mVolume);
when(mVolume.isMountedReadable()).thenReturn(true);
mController.displayPreference(screen);
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(null);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(null);
mController.setVolume(mVolume);
verify(screen).removePreference(files);
// This will hide it initially.
mController.displayPreference(screen);
- when(mSvp.findEmulatedForPrivate(any(VolumeInfo.class))).thenReturn(mVolume);
+ when(mSvp.findEmulatedForPrivate(nullable(VolumeInfo.class))).thenReturn(mVolume);
when(mVolume.isMountedReadable()).thenReturn(true);
// And we bring it back.
package com.android.settings.enterprise;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import java.util.ArrayList;
import java.util.List;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.anyObject;
-import static org.mockito.Mockito.when;
-
/**
* Tests for {@link EnterpriseSetDefaultAppsPreferenceController}.
*/
final List<UserAppInfo> apps = new ArrayList<>(number);
apps.add(new UserAppInfo(new UserInfo(i, "user." + i, UserInfo.FLAG_ADMIN), appInfo));
when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(eq(i),
- argThat(new MatchesIntents(intents)))).thenReturn(apps);
+ argThat(matchesIntents(intents)))).thenReturn(apps);
}
}
@Test
public void testIsAvailable() {
when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(anyInt(),
- anyObject())).thenReturn(new ArrayList<UserAppInfo>());
+ any(Intent[].class))).thenReturn(new ArrayList<>());
assertThat(mController.isAvailable()).isFalse();
setEnterpriseSetDefaultApps(EnterpriseDefaultApps.BROWSER.getIntents(), 1);
.isEqualTo("number_enterprise_set_default_apps");
}
- private static class MatchesIntents extends ArgumentMatcher<Intent[]> {
- private final Intent[] mExpectedIntents;
-
- MatchesIntents(Intent[] intents) {
- mExpectedIntents = intents;
- }
-
- @Override
- public boolean matches(Object object) {
- final Intent[] actualIntents = (Intent[]) object;
+ private ArgumentMatcher<Intent[]> matchesIntents(Intent[] intents) {
+ return (Intent[] actualIntents) -> {
if (actualIntents == null) {
return false;
}
- if (actualIntents.length != mExpectedIntents.length) {
+ if (actualIntents.length != intents.length) {
return false;
}
- for (int i = 0; i < mExpectedIntents.length; i++) {
- if (!mExpectedIntents[i].filterEquals(actualIntents[i])) {
+ for (int i = 0; i < intents.length; i++) {
+ if (!intents[i].filterEquals(actualIntents[i])) {
return false;
}
}
return true;
- }
+ };
}
}
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import android.app.Activity;
+import android.app.Fragment;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
doReturn(mContext).when(mFragment).getContext();
doReturn(mActivity).when(mFragment).getActivity();
doReturn(SUMMARY).when(mFragment).getString(anyInt());
- doReturn(APP_LABEL).when(mBundle).getString(anyString());
+ doReturn(APP_LABEL).when(mBundle).getString(nullable(String.class));
doReturn(mBundle).when(mFragment).getArguments();
ShadowEntityHeaderController.setUseMock(mEntityHeaderController);
doReturn(mEntityHeaderController).when(mEntityHeaderController)
- .setRecyclerView(any(RecyclerView.class), any(Lifecycle.class));
+ .setRecyclerView(nullable(RecyclerView.class), nullable(Lifecycle.class));
doReturn(mEntityHeaderController).when(mEntityHeaderController)
.setButtonActions(anyInt(), anyInt());
doReturn(mEntityHeaderController).when(mEntityHeaderController)
- .setIcon(any(Drawable.class));
- doReturn(mEntityHeaderController).when(mEntityHeaderController).setIcon(any(
+ .setIcon(nullable(Drawable.class));
+ doReturn(mEntityHeaderController).when(mEntityHeaderController).setIcon(nullable(
ApplicationsState.AppEntry.class));
- doReturn(mEntityHeaderController).when(mEntityHeaderController).setLabel(anyString());
doReturn(mEntityHeaderController).when(mEntityHeaderController)
- .setLabel(any(ApplicationsState.AppEntry.class));
- doReturn(mEntityHeaderController).when(mEntityHeaderController).setSummary(anyString());
+ .setLabel(nullable(String.class));
+ doReturn(mEntityHeaderController).when(mEntityHeaderController)
+ .setLabel(nullable(String.class));
+ doReturn(mEntityHeaderController).when(mEntityHeaderController)
+ .setLabel(nullable(ApplicationsState.AppEntry.class));
+ doReturn(mEntityHeaderController).when(mEntityHeaderController)
+ .setSummary(nullable(String.class));
doReturn(UID).when(mBatterySipper).getUid();
doReturn(APP_LABEL).when(mBatteryEntry).getLabel();
final ArgumentCaptor<Bundle> captor = ArgumentCaptor.forClass(Bundle.class);
- Answer<Void> callable = new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Exception {
- mBundle = captor.getValue();
- return null;
- }
+ Answer<Void> callable = invocation -> {
+ mBundle = captor.getValue();
+ return null;
};
- doAnswer(callable).when(mTestActivity).startPreferencePanelAsUser(any(), anyString(),
- captor.capture(), anyInt(), any(), any());
+ doAnswer(callable).when(mTestActivity).startPreferencePanelAsUser(
+ nullable(Fragment.class), nullable(String.class), captor.capture(), anyInt(),
+ nullable(CharSequence.class), nullable(UserHandle.class));
}
@After
mFragment.mAppEntry = null;
mFragment.initHeader();
- verify(mEntityHeaderController).setIcon(any(Drawable.class));
+ verify(mEntityHeaderController).setIcon(nullable(Drawable.class));
verify(mEntityHeaderController).setLabel(APP_LABEL);
}
mBatteryEntry, USAGE_PERCENT);
verify(mTestActivity).startPreferencePanelAsUser(
- any(), anyString(), any(), anyInt(), any(), eq(new UserHandle(10)));
+ nullable(Fragment.class), nullable(String.class), nullable(Bundle.class), anyInt(),
+ nullable(CharSequence.class), eq(new UserHandle(10)));
}
@Test
public void testStartBatteryDetailPage_noBatteryUsage_hasBasicData() {
final ArgumentCaptor<Bundle> captor = ArgumentCaptor.forClass(Bundle.class);
- Answer<Void> callable = new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Exception {
- mBundle = captor.getValue();
- return null;
- }
+ Answer<Void> callable = invocation -> {
+ mBundle = captor.getValue();
+ return null;
};
- doAnswer(callable).when(mTestActivity).startPreferencePanelAsUser(any(), anyString(),
- captor.capture(), anyInt(), any(), any());
+ doAnswer(callable).when(mTestActivity).startPreferencePanelAsUser(nullable(Fragment.class),
+ nullable(String.class), captor.capture(), anyInt(), nullable(CharSequence.class),
+ nullable(UserHandle.class));
AdvancedPowerUsageDetail.startBatteryDetailPage(mTestActivity, null, PACKAGE_NAME[0]);
*/
package com.android.settings.fuelgauge;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
-import android.os.PowerManager;
import android.support.v7.preference.PreferenceViewHolder;
import android.view.LayoutInflater;
import android.view.View;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
-import org.robolectric.util.ReflectionHelpers;
-
-import static org.mockito.AdditionalMatchers.not;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
@RunWith(SettingsRobolectricTestRunner.class)
mBatteryHistoryPreference.onBindViewHolder(mViewHolder);
verify(mViewHolder).findViewById(R.id.battery_usage);
- verify(mTextView).setText(anyString());
+ verify(mTextView).setText(nullable(String.class));
verify(mBatteryInfo).bindHistory(mUsageView);
}
}
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
final boolean handled = mController.handlePreferenceTreeClick(mPreference);
assertThat(handled).isTrue();
- verify(mSettingsActivity).startPreferencePanel(any(Fragment.class),
- anyString(), any(Bundle.class), anyInt(), any(CharSequence.class),
- any(Fragment.class), anyInt());
+ verify(mSettingsActivity).startPreferencePanel(nullable(Fragment.class),
+ nullable(String.class), nullable(Bundle.class), anyInt(),
+ nullable(CharSequence.class), nullable(Fragment.class), anyInt());
}
@Test
final boolean handled = mController.handlePreferenceTreeClick(mPreference);
assertThat(handled).isFalse();
- verify(mSettingsActivity, never()).startPreferencePanel(any(Fragment.class),
- anyString(), any(Bundle.class), anyInt(), any(CharSequence.class),
- any(Fragment.class), anyInt());
+ verify(mSettingsActivity, never()).startPreferencePanel(nullable(Fragment.class),
+ nullable(String.class), nullable(Bundle.class), anyInt(),
+ nullable(CharSequence.class), nullable(Fragment.class), anyInt());
}
@Test
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
mContext = spy(RuntimeEnvironment.application);
ReflectionHelpers.setField(mPolicy, "wakeLockThreshold", WAKELOCK_THRESHOLD_MS);
- doReturn(false).when(mBatteryUtils).shouldHideSipper(any());
+ doReturn(false).when(mBatteryUtils).shouldHideSipper(nullable(BatterySipper.class));
doReturn(mPackageManager).when(mContext).getPackageManager();
- doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo(anyString(), anyInt());
+ doReturn(mApplicationInfo).when(mPackageManager)
+ .getApplicationInfo(nullable(String.class), anyInt());
mAnomalySipper.uidObj = mAnomalyUid;
mAnomalyWakelocks = new ArrayMap<>();
*/
package com.android.settings.location;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class LocationPreferenceControllerTest {
public void updateState_shouldSetSummary() {
mController.updateState(mPreference);
- verify(mPreference).setSummary(anyString());
+ verify(mPreference).setSummary(nullable(String.class));
}
@Test
mController.displayPreference(mScreen);
mController.updateSummary();
- verify(mPreference).setSummary(anyString());
+ verify(mPreference).setSummary(nullable(String.class));
}
@Test
import java.util.List;
import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
mFragment.onCreateOptionsMenu(null, null);
- verify(resetController).buildMenuItem(any(Menu.class));
+ verify(resetController).buildMenuItem(nullable(Menu.class));
}
@Test
package com.android.settings.notification;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import com.android.internal.logging.nano.MetricsProto;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class NotificationAccessSettingsTest {
@Test
public void logSpecialPermissionChange() {
mFragment.logSpecialPermissionChange(true, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_NOTIVIEW_ALLOW),
eq("app"));
mFragment.logSpecialPermissionChange(false, "app");
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
+ verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_NOTIVIEW_DENY),
eq("app"));
}
package com.android.settings.notification;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
-import android.preference.SeekBarVolumizer;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class VolumeSeekBarPreferenceControllerTest {
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- when(mScreen.findPreference(anyString())).thenReturn(mPreference);
+ when(mScreen.findPreference(nullable(String.class))).thenReturn(mPreference);
mController =
new VolumeSeekBarPreferenceControllerTestable(mContext, mCallback);
}
package com.android.settings.notification;
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import android.content.Context;
import android.os.UserHandle;
import android.os.UserManager;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class WorkSoundPreferenceControllerTest {
@Test
public void isAvailable_managedProfileAndNotSingleVolume_shouldReturnTrue() {
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
when(mAudioHelper.isSingleVolume()).thenReturn(false);
assertThat(mController.isAvailable()).isTrue();
@Test
public void isAvailable_noManagedProfile_shouldReturnFalse() {
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.USER_NULL);
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
when(mAudioHelper.isSingleVolume()).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
@Test
public void isAvailable_singleVolume_shouldReturnFalse() {
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
when(mAudioHelper.isSingleVolume()).thenReturn(true);
assertThat(mController.isAvailable()).isFalse();
when(mAudioHelper.isSingleVolume()).thenReturn(false);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext);
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.USER_NULL);
// When the fragment first displays, the category should not appear.
// However, when a managed profile is added later, the category should appear.
mController.onResume();
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
mController.onManagedProfileAdded(UserHandle.myUserId());
when(mAudioHelper.isSingleVolume()).thenReturn(false);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext);
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
// Which is in resumed state:
mController.displayPreference(mScreen);
verify(mWorkCategory, times(2)).setVisible(true);
// When a managed profile is removed, the category should be hidden.
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.USER_NULL);
mController.onManagedProfileRemoved(UserHandle.myUserId());
@Test
public void displayPreference_isAvailable_shouldShowPreferenceCategory() {
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
when(mAudioHelper.isSingleVolume()).thenReturn(false);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext);
@Test
public void displayPreference_notAvailable_shouldHidePreferenceCategory() {
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.USER_NULL);
when(mAudioHelper.isSingleVolume()).thenReturn(true);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
mController.onPreferenceChange(preference, "hello");
- verify(preference).setSummary(anyString());
+ verify(preference).setSummary(nullable(String.class));
}
@Test
when(mTelephonyManager.isVoiceCapable()).thenReturn(false);
mController = new WorkSoundPreferenceController(mContext, mFragment, null, mAudioHelper);
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
when(mAudioHelper.isSingleVolume()).thenReturn(false);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext);
when(mAudioHelper.isSingleVolume()).thenReturn(false);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext);
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(UserHandle.myUserId());
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(false);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(false);
// When resumed:
mController.displayPreference(mScreen);
@Test
public void onResume_shouldSetUserIdToPreference() {
final int managedProfileUserId = 10;
- when(mAudioHelper.getManagedProfileId(any(UserManager.class)))
+ when(mAudioHelper.getManagedProfileId(nullable(UserManager.class)))
.thenReturn(managedProfileUserId);
- when(mAudioHelper.isUserUnlocked(any(UserManager.class), anyInt())).thenReturn(true);
+ when(mAudioHelper.isUserUnlocked(nullable(UserManager.class), anyInt())).thenReturn(true);
when(mAudioHelper.isSingleVolume()).thenReturn(false);
when(mFragment.getPreferenceScreen()).thenReturn(mScreen);
when(mAudioHelper.createPackageContextAsUser(anyInt())).thenReturn(mContext);
import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyInt;
@Test
public void upgradeQuality_noDpmRequirement_shouldReturnQuality() {
doReturn(DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED)
- .when(mDevicePolicyManager).getPasswordQuality(any(ComponentName.class), anyInt());
+ .when(mDevicePolicyManager)
+ .getPasswordQuality(nullable(ComponentName.class), anyInt());
int upgradedQuality = mController.upgradeQuality(
DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC);
@Test
public void upgradeQuality_dpmRequirement_shouldReturnRequiredQuality() {
doReturn(DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC)
- .when(mDevicePolicyManager).getPasswordQuality(any(ComponentName.class), anyInt());
+ .when(mDevicePolicyManager)
+ .getPasswordQuality(nullable(ComponentName.class), anyInt());
int upgradedQuality = mController.upgradeQuality(
DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
package com.android.settings.search;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class SavedQueryViewHolderTest {
mTitleView.performClick();
mRemoveButton.performClick();
- verify(mSearchFragment).onSavedQueryClicked(any(CharSequence.class));
- verify(mSearchFragment).onRemoveSavedQueryClicked(any(CharSequence.class));
+ verify(mSearchFragment).onSavedQueryClicked(nullable(CharSequence.class));
+ verify(mSearchFragment).onRemoveSavedQueryClicked(nullable(CharSequence.class));
}
}
import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.inOrder;
when(mockConnectivityManager.getNetworkInfo(any(Network.class)))
.thenReturn(mockNetworkInfo);
doNothing().when(mockConnectivityManagerWrapper).registerNetworkCallback(
- any(NetworkRequest.class), mCallbackCaptor.capture(), any(Handler.class));
+ nullable(NetworkRequest.class), mCallbackCaptor.capture(), nullable(Handler.class));
doNothing().when(mockForgetButton).setOnClickListener(mForgetClickListener.capture());
when(mockWifiInfo.getLinkSpeed()).thenReturn(LINK_SPEED);
mController.onResume();
verify(mockConnectivityManagerWrapper, times(1)).registerNetworkCallback(
- any(NetworkRequest.class), mCallbackCaptor.capture(), any(Handler.class));
+ nullable(NetworkRequest.class), mCallbackCaptor.capture(), nullable(Handler.class));
}
@Test
OSDN Git Service
