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

Merge "Merge "Update Anomaly detection framework" into oc-dr1-dev am: 690accadc7" into oc-dr1-dev-plus-aosp

Browse Source 
am: 0291cbb58e

Change-Id: I7942d4ab3bd2ceb29375dd62c58ff319b9d5d9e8
This commit is contained in:
jackqdyulei
2017-07-07 03:34:24 +00:00
committed by android-build-merger
parent 4d7675ad0c 0291cbb58e
commit dadbcfca37
20 changed files with 457 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tests/robotests/src/com/android/settings/applications/InstalledAppDetailsTest.java
View File

@@ -18,6 +18,7 @@ package com.android.settings.applications;
import android.app.AlertDialog;
import android.app.AppOpsManager;
import android.app.Fragment;
import android.app.LoaderManager;
import android.app.admin.DevicePolicyManager;
@@ -113,6 +114,8 @@ public final class InstalledAppDetailsTest {
private BatteryUtils mBatteryUtils;
@Mock
private LoaderManager mLoaderManager;
@Mock
private AppOpsManager mAppOpsManager;
private FakeFeatureFactory mFeatureFactory;
private InstalledAppDetails mAppDetail;
@@ -138,6 +141,7 @@ public final class InstalledAppDetailsTest {
doReturn(mActivity).when(mAppDetail).getActivity();
doReturn(mShadowContext).when(mAppDetail).getContext();
doReturn(mPackageManager).when(mActivity).getPackageManager();
doReturn(mAppOpsManager).when(mActivity).getSystemService(Context.APP_OPS_SERVICE);
// Default to not considering any apps to be instant (individual tests can override this).
ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",

4
tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
View File

@@ -30,6 +30,7 @@ import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.app.Activity;
import android.app.AppOpsManager;
import android.app.Fragment;
import android.app.LoaderManager;
import android.content.Context;
@@ -116,6 +117,8 @@ public class AdvancedPowerUsageDetailTest {
@Mock
private PackageManager mPackageManager;
@Mock
private AppOpsManager mAppOpsManager;
@Mock
private LoaderManager mLoaderManager;
@Mock
private AnomalySummaryPreferenceController mAnomalySummaryPreferenceController;
@@ -184,6 +187,7 @@ public class AdvancedPowerUsageDetailTest {
mTestActivity = spy(new SettingsActivity());
doReturn(mPackageManager).when(mTestActivity).getPackageManager();
doReturn(mAppOpsManager).when(mTestActivity).getSystemService(Context.APP_OPS_SERVICE);
final ArgumentCaptor<Bundle> captor = ArgumentCaptor.forClass(Bundle.class);

58
tests/robotests/src/com/android/settings/fuelgauge/BatteryUtilsTest.java
View File

@@ -15,9 +15,13 @@
*/
package com.android.settings.fuelgauge;
import android.app.AppOpsManager;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.os.BatteryStats;
import android.os.Bundle;
import android.os.Build;
import android.os.Process;
import android.os.SystemClock;
import android.os.UserManager;
@@ -58,6 +62,7 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -96,6 +101,8 @@ public class BatteryUtilsTest {
private static final int DISCHARGE_AMOUNT = 80;
private static final double PERCENT_SYSTEM_USAGE = 60;
private static final double PRECISION = 0.001;
private static final int SDK_VERSION = Build.VERSION_CODES.L;
private static final String PACKAGE_NAME = "com.android.app";
@Mock
private BatteryStats.Uid mUid;
@@ -123,6 +130,12 @@ public class BatteryUtilsTest {
private Bundle mBundle;
@Mock
private UserManager mUserManager;
@Mock
private PackageManager mPackageManager;
@Mock
private AppOpsManager mAppOpsManager;
@Mock
private ApplicationInfo mApplicationInfo;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
@@ -177,10 +190,11 @@ public class BatteryUtilsTest {
mIdleBatterySipper.drainType = BatterySipper.DrainType.IDLE;
mIdleBatterySipper.totalPowerMah = BATTERY_IDLE_USAGE;
mBatteryUtils = BatteryUtils.getInstance(RuntimeEnvironment.application);
final Context shadowContext = spy(RuntimeEnvironment.application);
doReturn(mPackageManager).when(shadowContext).getPackageManager();
doReturn(mAppOpsManager).when(shadowContext).getSystemService(Context.APP_OPS_SERVICE);
mBatteryUtils = spy(new BatteryUtils(shadowContext));
mBatteryUtils.mPowerUsageFeatureProvider = mProvider;
mBatteryUtils = spy(new BatteryUtils(RuntimeEnvironment.application));
}
@Test
@@ -392,6 +406,44 @@ public class BatteryUtilsTest {
TIME_SINCE_LAST_FULL_CHARGE_US);
}
@Test
public void testGetTargetSdkVersion_packageExist_returnSdk() throws
PackageManager.NameNotFoundException {
doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo(PACKAGE_NAME,
PackageManager.GET_META_DATA);
mApplicationInfo.targetSdkVersion = SDK_VERSION;
assertThat(mBatteryUtils.getTargetSdkVersion(PACKAGE_NAME)).isEqualTo(SDK_VERSION);
}
@Test
public void testGetTargetSdkVersion_packageNotExist_returnSdkNull() throws
PackageManager.NameNotFoundException {
doThrow(new PackageManager.NameNotFoundException()).when(
mPackageManager).getApplicationInfo(PACKAGE_NAME, PackageManager.GET_META_DATA);
assertThat(mBatteryUtils.getTargetSdkVersion(PACKAGE_NAME)).isEqualTo(
BatteryUtils.SDK_NULL);
}
@Test
public void testBackgroundRestrictionOn_restrictionOn_returnTrue() {
doReturn(AppOpsManager.MODE_IGNORED).when(mAppOpsManager).checkOpNoThrow(
AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
assertThat(mBatteryUtils.isBackgroundRestrictionEnabled(SDK_VERSION, UID,
PACKAGE_NAME)).isTrue();
}
@Test
public void testBackgroundRestrictionOn_restrictionOff_returnFalse() {
doReturn(AppOpsManager.MODE_ALLOWED).when(mAppOpsManager).checkOpNoThrow(
AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
assertThat(mBatteryUtils.isBackgroundRestrictionEnabled(SDK_VERSION, UID,
PACKAGE_NAME)).isFalse();
}
private BatterySipper createTestSmearBatterySipper(long topTime,
double totalPowerMah, int uidCode, boolean isUidNull) {
final BatterySipper sipper = mock(BatterySipper.class);

35
tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyDialogFragmentTest.java
View File

@@ -18,6 +18,7 @@ package com.android.settings.fuelgauge.anomaly;
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.doNothing;
import static org.mockito.Mockito.doReturn;
@@ -27,6 +28,7 @@ import static org.robolectric.Shadows.shadowOf;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Build;
import com.android.settings.R;
import com.android.settings.fuelgauge.anomaly.action.AnomalyAction;
@@ -57,6 +59,7 @@ public class AnomalyDialogFragmentTest {
private AnomalyAction mAnomalyAction;
private Anomaly mWakeLockAnomaly;
private Anomaly mWakeupAlarmAnomaly;
private Anomaly mWakeupAlarmAnomaly2;
private Anomaly mBluetoothAnomaly;
private AnomalyDialogFragment mAnomalyDialogFragment;
private Context mContext;
@@ -78,6 +81,13 @@ public class AnomalyDialogFragmentTest {
.setPackageName(PACKAGE_NAME)
.setDisplayName(DISPLAY_NAME)
.build();
mWakeupAlarmAnomaly2 = new Anomaly.Builder()
.setType(Anomaly.AnomalyType.WAKEUP_ALARM)
.setUid(UID)
.setPackageName(PACKAGE_NAME)
.setDisplayName(DISPLAY_NAME)
.setTargetSdkVersion(Build.VERSION_CODES.O)
.build();
mBluetoothAnomaly = new Anomaly.Builder()
.setType(Anomaly.AnomalyType.BLUETOOTH_SCAN)
.setUid(UID)
@@ -116,7 +126,7 @@ public class AnomalyDialogFragmentTest {
}
@Test
public void testOnCreateDialog_wakeupAlarmAnomaly_fireBackgroundCheckDialog() {
public void testOnCreateDialog_wakeupAlarmAnomalyPriorO_fireStopAndBackgroundCheckDialog() {
mAnomalyDialogFragment = AnomalyDialogFragment.newInstance(mWakeupAlarmAnomaly,
0 /* metricskey */);
@@ -136,12 +146,33 @@ public class AnomalyDialogFragmentTest {
mContext.getString(R.string.dlg_cancel));
}
@Test
public void testOnCreateDialog_wakeupAlarmAnomalyTargetingO_fireForceStopDialog() {
mAnomalyDialogFragment = AnomalyDialogFragment.newInstance(mWakeupAlarmAnomaly2,
0 /* metricskey */);
FragmentTestUtil.startFragment(mAnomalyDialogFragment);
final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
ShadowAlertDialog shadowDialog = shadowOf(dialog);
assertThat(shadowDialog.getMessage()).isEqualTo(
mContext.getString(R.string.dialog_stop_message_wakeup_alarm,
mWakeLockAnomaly.displayName));
assertThat(shadowDialog.getTitle()).isEqualTo(
mContext.getString(R.string.dialog_stop_title));
assertThat(dialog.getButton(DialogInterface.BUTTON_POSITIVE).getText()).isEqualTo(
mContext.getString(R.string.dialog_stop_ok));
assertThat(dialog.getButton(DialogInterface.BUTTON_NEGATIVE).getText()).isEqualTo(
mContext.getString(R.string.dlg_cancel));
}
@Test
public void testOnCreateDialog_bluetoothAnomaly_fireLocationCheckDialog() {
mAnomalyDialogFragment = spy(AnomalyDialogFragment.newInstance(mBluetoothAnomaly,
0 /* metricskey */));
mAnomalyDialogFragment.mAnomalyUtils = mAnomalyUtils;
doReturn(mAnomalyAction).when(mAnomalyUtils).getAnomalyAction(anyInt());
doReturn(mAnomalyAction).when(mAnomalyUtils).getAnomalyAction(any());
doNothing().when(mAnomalyDialogFragment).initAnomalyUtils();
doReturn(Anomaly.AnomalyActionType.LOCATION_CHECK).when(mAnomalyAction).getActionType();

7
tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyTest.java
View File

@@ -18,6 +18,8 @@ package com.android.settings.fuelgauge.anomaly;
import static com.google.common.truth.Truth.assertThat;
import android.os.Build;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
@@ -30,6 +32,7 @@ import org.robolectric.annotation.Config;
public class AnomalyTest {
private static int TYPE = Anomaly.AnomalyType.WAKE_LOCK;
private static int UID = 111;
private static int SDK_VERSION = Build.VERSION_CODES.L;
private static long WAKE_LOCK_TIME_MS = 1500;
private static String PACKAGE_NAME = "com.android.settings";
private static String DISPLAY_NAME = "settings";
@@ -42,6 +45,8 @@ public class AnomalyTest {
.setWakeLockTimeMs(WAKE_LOCK_TIME_MS)
.setPackageName(PACKAGE_NAME)
.setDisplayName(DISPLAY_NAME)
.setTargetSdkVersion(SDK_VERSION)
.setBackgroundRestrictionEnabled(true)
.build();
assertThat(anomaly.type).isEqualTo(TYPE);
@@ -49,5 +54,7 @@ public class AnomalyTest {
assertThat(anomaly.wakelockTimeMs).isEqualTo(WAKE_LOCK_TIME_MS);
assertThat(anomaly.packageName).isEqualTo(PACKAGE_NAME);
assertThat(anomaly.displayName).isEqualTo(DISPLAY_NAME);
assertThat(anomaly.targetSdkVersion).isEqualTo(SDK_VERSION);
assertThat(anomaly.backgroundRestrictionEnabled).isTrue();
}
}

47
tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyUtilsTest.java
View File

@@ -18,9 +18,11 @@ package com.android.settings.fuelgauge.anomaly;
import static com.google.common.truth.Truth.assertThat;
import android.os.Build;
import com.android.settings.fuelgauge.anomaly.action.StopAndBackgroundCheckAction;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.fuelgauge.anomaly.action.BackgroundCheckAction;
import com.android.settings.fuelgauge.anomaly.action.ForceStopAction;
import com.android.settings.fuelgauge.anomaly.checker.WakeLockAnomalyDetector;
import com.android.settings.testutils.shadow.ShadowKeyValueListParserWrapperImpl;
@@ -45,22 +47,51 @@ public class AnomalyUtilsTest {
@Test
public void testGetAnomalyAction_typeWakeLock_returnForceStop() {
assertThat(mAnomalyUtils.getAnomalyAction(Anomaly.AnomalyType.WAKE_LOCK)).isInstanceOf(
Anomaly anomaly = new Anomaly.Builder()
.setType(Anomaly.AnomalyType.WAKE_LOCK)
.build();
assertThat(mAnomalyUtils.getAnomalyAction(anomaly)).isInstanceOf(
ForceStopAction.class);
}
@Test
public void testGetAnomalyAction_typeWakeUpAlarm_returnBackgroundCheck() {
assertThat(mAnomalyUtils.getAnomalyAction(Anomaly.AnomalyType.WAKEUP_ALARM)).isInstanceOf(
BackgroundCheckAction.class);
}
@Test
public void testGetAnomalyDetector_typeWakeLock_returnWakeLockDetector() {
assertThat(mAnomalyUtils.getAnomalyDetector(Anomaly.AnomalyType.WAKE_LOCK)).isInstanceOf(
WakeLockAnomalyDetector.class);
}
@Test
public void testGetAnomalyAction_typeWakeUpAlarmTargetO_returnForceStop() {
Anomaly anomaly = new Anomaly.Builder()
.setType(Anomaly.AnomalyType.WAKEUP_ALARM)
.setTargetSdkVersion(Build.VERSION_CODES.O)
.build();
assertThat(mAnomalyUtils.getAnomalyAction(anomaly)).isInstanceOf(
ForceStopAction.class);
}
@Test
public void testGetAnomalyAction_typeWakeUpAlarmTargetPriorOAndBgOff_returnStopAndBackground() {
Anomaly anomaly = new Anomaly.Builder()
.setType(Anomaly.AnomalyType.WAKEUP_ALARM)
.setTargetSdkVersion(Build.VERSION_CODES.L)
.setBackgroundRestrictionEnabled(false)
.build();
assertThat(mAnomalyUtils.getAnomalyAction(anomaly)).isInstanceOf(
StopAndBackgroundCheckAction.class);
}
@Test
public void testGetAnomalyAction_typeWakeUpAlarmTargetPriorOAndBgOn_returnForceStop() {
Anomaly anomaly = new Anomaly.Builder()
.setType(Anomaly.AnomalyType.WAKEUP_ALARM)
.setTargetSdkVersion(Build.VERSION_CODES.L)
.setBackgroundRestrictionEnabled(true)
.build();
assertThat(mAnomalyUtils.getAnomalyAction(anomaly)).isInstanceOf(
ForceStopAction.class);
}
@Test
public void testGetAnomalyDetector_typeWakeUpAlarm_returnWakeUpAlarmDetector() {
assertThat(mAnomalyUtils.getAnomalyDetector(Anomaly.AnomalyType.WAKEUP_ALARM)).isInstanceOf(

21
tests/robotests/src/com/android/settings/fuelgauge/anomaly/action/BackgroundCheckActionTest.java
View File

@@ -23,7 +23,9 @@ import static org.mockito.Mockito.verify;
import android.app.AppOpsManager;
import android.content.Context;
import android.os.Build;
import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.fuelgauge.anomaly.Anomaly;
@@ -42,11 +44,14 @@ import org.robolectric.annotation.Config;
public class BackgroundCheckActionTest {
private static final String PACKAGE_NAME = "com.android.app";
private static final int UID = 111;
private static final int SDK_VERSION = Build.VERSION_CODES.L;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock
private AppOpsManager mAppOpsManagerr;
private AppOpsManager mAppOpsManager;
@Mock
private BatteryUtils mBatteryUtils;
private Anomaly mAnomaly;
private BackgroundCheckAction mBackgroundCheckAction;
@@ -55,35 +60,37 @@ public class BackgroundCheckActionTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
doReturn(mAppOpsManagerr).when(mContext).getSystemService(Context.APP_OPS_SERVICE);
doReturn(mAppOpsManager).when(mContext).getSystemService(Context.APP_OPS_SERVICE);
mAnomaly = new Anomaly.Builder()
.setUid(UID)
.setPackageName(PACKAGE_NAME)
.setTargetSdkVersion(SDK_VERSION)
.build();
mBackgroundCheckAction = new BackgroundCheckAction(mContext);
mBackgroundCheckAction.mBatteryUtils = mBatteryUtils;
}
@Test
public void testHandlePositiveAction_forceStopPackage() {
mBackgroundCheckAction.handlePositiveAction(mAnomaly, 0 /* metricskey */);
verify(mAppOpsManagerr).setMode(AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME,
verify(mAppOpsManager).setMode(AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME,
AppOpsManager.MODE_IGNORED);
}
@Test
public void testIsActionActive_modeAllowed_returnTrue() {
doReturn(AppOpsManager.MODE_ALLOWED).when(mAppOpsManagerr).checkOpNoThrow(
AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
doReturn(false).when(mBatteryUtils).isBackgroundRestrictionEnabled(SDK_VERSION, UID,
PACKAGE_NAME);
assertThat(mBackgroundCheckAction.isActionActive(mAnomaly)).isTrue();
}
@Test
public void testIsActionActive_modeIgnored_returnFalse() {
doReturn(AppOpsManager.MODE_IGNORED).when(mAppOpsManagerr).checkOpNoThrow(
AppOpsManager.OP_RUN_IN_BACKGROUND, UID, PACKAGE_NAME);
doReturn(true).when(mBatteryUtils).isBackgroundRestrictionEnabled(SDK_VERSION, UID,
PACKAGE_NAME);
assertThat(mBackgroundCheckAction.isActionActive(mAnomaly)).isFalse();
}

93
tests/robotests/src/com/android/settings/fuelgauge/anomaly/action/StopAndBackgroundActionTest.java Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.fuelgauge.anomaly.action;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import android.content.Context;
import com.android.settings.TestConfig;
import com.android.settings.fuelgauge.anomaly.Anomaly;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class StopAndBackgroundActionTest {
private static final String PACKAGE_NAME = "com.android.app";
private static final int UID = 111;
private static final int METRICS_KEY = 3;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock
private BackgroundCheckAction mBackgroundCheckAction;
@Mock
private ForceStopAction mForceStopAction;
private StopAndBackgroundCheckAction mStopAndBackgroundCheckAction;
private Anomaly mAnomaly;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
mAnomaly = new Anomaly.Builder()
.setUid(UID)
.setPackageName(PACKAGE_NAME)
.build();
FakeFeatureFactory.setupForTest(mContext);
mStopAndBackgroundCheckAction = new StopAndBackgroundCheckAction(mContext, mForceStopAction,
mBackgroundCheckAction);
}
@Test
public void testHandlePositiveAction_stopAndBackgroundCheck() {
mStopAndBackgroundCheckAction.handlePositiveAction(mAnomaly, METRICS_KEY);
verify(mBackgroundCheckAction).handlePositiveAction(mAnomaly, METRICS_KEY);
verify(mForceStopAction).handlePositiveAction(mAnomaly, METRICS_KEY);
}
@Test
public void testIsActionActive_restrictionEnabled_returnFalse() {
doReturn(true).when(mForceStopAction).isActionActive(mAnomaly);
assertThat(mStopAndBackgroundCheckAction.isActionActive(mAnomaly)).isFalse();
}
@Test
public void testIsActionActive_appNotRunning_returnFalse() {
doReturn(true).when(mBackgroundCheckAction).isActionActive(mAnomaly);
assertThat(mStopAndBackgroundCheckAction.isActionActive(mAnomaly)).isFalse();
}
@Test
public void testIsActionActive_appStoppedAndRestrictionOn_returnFalse() {
assertThat(mStopAndBackgroundCheckAction.isActionActive(mAnomaly)).isFalse();
}
}

9
tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetectorTest.java
View File

@@ -36,6 +36,7 @@ import com.android.settings.TestConfig;
import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settings.fuelgauge.anomaly.Anomaly;
import com.android.settings.fuelgauge.anomaly.AnomalyDetectionPolicy;
import com.android.settings.fuelgauge.anomaly.AnomalyUtils;
import com.android.settings.fuelgauge.anomaly.action.AnomalyAction;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
@@ -80,6 +81,8 @@ public class BluetoothScanAnomalyDetectorTest {
private AnomalyDetectionPolicy mPolicy;
@Mock
private AnomalyAction mAnomalyAction;
@Mock
private AnomalyUtils mAnomalyUtils;
private BluetoothScanAnomalyDetector mBluetoothScanAnomalyDetector;
private Context mContext;
@@ -92,6 +95,7 @@ public class BluetoothScanAnomalyDetectorTest {
mContext = spy(RuntimeEnvironment.application);
ReflectionHelpers.setField(mPolicy, "bluetoothScanThreshold",
30 * DateUtils.MINUTE_IN_MILLIS);
doReturn(mAnomalyAction).when(mAnomalyUtils).getAnomalyAction(any());
mAnomalySipper.uidObj = mAnomalyUid;
doReturn(ANOMALY_UID).when(mAnomalyUid).getUid();
@@ -106,10 +110,9 @@ public class BluetoothScanAnomalyDetectorTest {
mUsageList.add(mTargetSipper);
doReturn(mUsageList).when(mBatteryStatsHelper).getUsageList();
mBluetoothScanAnomalyDetector = spy(
new BluetoothScanAnomalyDetector(mContext, mPolicy, mAnomalyAction));
mBluetoothScanAnomalyDetector = spy(new BluetoothScanAnomalyDetector(mContext, mPolicy,
mAnomalyUtils));
mBluetoothScanAnomalyDetector.mBatteryUtils = mBatteryUtils;
mBluetoothScanAnomalyDetector.mAnomalyAction = mAnomalyAction;
doReturn(false).when(mBatteryUtils).shouldHideSipper(any());
doReturn(true).when(mAnomalyAction).isActionActive(any());

8
tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/WakeLockAnomalyDetectorTest.java
View File

@@ -34,6 +34,7 @@ import android.text.format.DateUtils;
import com.android.internal.os.BatterySipper;
import com.android.internal.os.BatteryStatsHelper;
import com.android.settings.fuelgauge.anomaly.AnomalyUtils;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.fuelgauge.BatteryUtils;
@@ -92,6 +93,8 @@ public class WakeLockAnomalyDetectorTest {
private AnomalyDetectionPolicy mPolicy;
@Mock
private AnomalyAction mAnomalyAction;
@Mock
private AnomalyUtils mAnomalyUtils;
private WakeLockAnomalyDetector mWakelockAnomalyDetector;
private Context mContext;
@@ -109,10 +112,11 @@ public class WakeLockAnomalyDetectorTest {
doReturn(mApplicationInfo).when(mPackageManager)
.getApplicationInfo(nullable(String.class), anyInt());
doReturn(true).when(mAnomalyAction).isActionActive(any());
doReturn(mAnomalyAction).when(mAnomalyUtils).getAnomalyAction(any());
mWakelockAnomalyDetector = spy(new WakeLockAnomalyDetector(mContext, mPolicy));
mWakelockAnomalyDetector = spy(
new WakeLockAnomalyDetector(mContext, mPolicy, mAnomalyUtils));
mWakelockAnomalyDetector.mBatteryUtils = mBatteryUtils;
mWakelockAnomalyDetector.mAnomalyAction = mAnomalyAction;
mAnomalySipper.uidObj = mAnomalyUid;
doReturn(ANOMALY_WAKELOCK_TIME_MS).when(mWakelockAnomalyDetector)

8
tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/WakeupAlarmAnomalyDetectorTest.java
View File

@@ -33,6 +33,7 @@ import android.util.ArrayMap;
import com.android.internal.os.BatterySipper;
import com.android.internal.os.BatteryStatsHelper;
import com.android.settings.fuelgauge.anomaly.AnomalyUtils;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.fuelgauge.BatteryUtils;
@@ -89,6 +90,8 @@ public class WakeupAlarmAnomalyDetectorTest {
private AnomalyDetectionPolicy mPolicy;
@Mock
private AnomalyAction mAnomalyAction;
@Mock
private AnomalyUtils mAnomalyUtils;
private WakeupAlarmAnomalyDetector mWakeupAlarmAnomalyDetector;
private Context mContext;
@@ -105,6 +108,7 @@ public class WakeupAlarmAnomalyDetectorTest {
doReturn(RUNNING_TIME_MS).when(mBatteryUtils).calculateRunningTimeBasedOnStatsType(any(),
anyInt());
doReturn(true).when(mAnomalyAction).isActionActive(any());
doReturn(mAnomalyAction).when(mAnomalyUtils).getAnomalyAction(any());
mAnomalySipper.uidObj = mAnomalyUid;
doReturn(ANOMALY_UID).when(mAnomalyUid).getUid();
@@ -119,9 +123,9 @@ public class WakeupAlarmAnomalyDetectorTest {
mUsageList.add(mTargetSipper);
doReturn(mUsageList).when(mBatteryStatsHelper).getUsageList();
mWakeupAlarmAnomalyDetector = spy(new WakeupAlarmAnomalyDetector(mContext, mPolicy));
mWakeupAlarmAnomalyDetector = spy(
new WakeupAlarmAnomalyDetector(mContext, mPolicy, mAnomalyUtils));
mWakeupAlarmAnomalyDetector.mBatteryUtils = mBatteryUtils;
mWakeupAlarmAnomalyDetector.mAnomalyAction = mAnomalyAction;
}
@Test