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

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.fuelgauge.anomaly.checker;
  18
  19 import static com.google.common.truth.Truth.assertThat;
  20
  21 import static org.mockito.ArgumentMatchers.nullable;
  22 import static org.mockito.Matchers.any;
  23 import static org.mockito.Matchers.anyInt;
  24 import static org.mockito.Matchers.eq;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.spy;
  27
  28 import android.content.Context;
  29 import android.content.pm.ApplicationInfo;
  30 import android.os.BatteryStats;
  31 import android.text.format.DateUtils;
  32 import android.util.ArrayMap;
  33
  34 import com.android.internal.os.BatterySipper;
  35 import com.android.internal.os.BatteryStatsHelper;
  36 import com.android.settings.testutils.SettingsRobolectricTestRunner;
  37 import com.android.settings.TestConfig;
  38 import com.android.settings.fuelgauge.BatteryUtils;
  39 import com.android.settings.fuelgauge.anomaly.Anomaly;
  40 import com.android.settings.fuelgauge.anomaly.AnomalyDetectionPolicy;
  41 import com.android.settings.fuelgauge.anomaly.action.AnomalyAction;
  42
  43 import org.junit.Before;
  44 import org.junit.Test;
  45 import org.junit.runner.RunWith;
  46 import org.mockito.Mock;
  47 import org.mockito.MockitoAnnotations;
  48 import org.robolectric.RuntimeEnvironment;
  49 import org.robolectric.annotation.Config;
  50 import org.robolectric.util.ReflectionHelpers;
  51
  52 import java.util.ArrayList;
  53 import java.util.List;
  54
  55 @RunWith(SettingsRobolectricTestRunner.class)
  56 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
  57 public class WakeupAlarmAnomalyDetectorTest {
  58     private static final String TARGET_PACKAGE_NAME = "com.android.app";
  59     private static final int ANOMALY_UID = 111;
  60     private static final int NORMAL_UID = 222;
  61     private static final int TARGET_UID = 333;
  62     private static final long RUNNING_TIME_MS =
  63             1 * DateUtils.HOUR_IN_MILLIS + 10 * DateUtils.MINUTE_IN_MILLIS;
  64     private static final int ANOMALY_WAKEUP_COUNT = 500;
  65     private static final int NORMAL_WAKEUP_COUNT = 61;
  66     @Mock
  67     private BatteryStatsHelper mBatteryStatsHelper;
  68     @Mock
  69     private BatterySipper mAnomalySipper;
  70     @Mock
  71     private BatterySipper mNormalSipper;
  72     @Mock
  73     private BatterySipper mTargetSipper;
  74     @Mock
  75     private BatteryStats.Uid mAnomalyUid;
  76     @Mock
  77     private BatteryStats.Uid mNormalUid;
  78     @Mock
  79     private BatteryStats.Uid mTargetUid;
  80     @Mock
  81     private BatteryUtils mBatteryUtils;
  82     @Mock
  83     private ApplicationInfo mApplicationInfo;
  84     @Mock
  85     private BatteryStats.Uid.Pkg mPkg;
  86     @Mock
  87     private BatteryStats.Counter mCounter;
  88     @Mock
  89     private AnomalyDetectionPolicy mPolicy;
  90     @Mock
  91     private AnomalyAction mAnomalyAction;
  92
  93     private WakeupAlarmAnomalyDetector mWakeupAlarmAnomalyDetector;
  94     private Context mContext;
  95     private List<BatterySipper> mUsageList;
  96
  97     @Before
  98     public void setUp() throws Exception {
  99         MockitoAnnotations.initMocks(this);
 100
 101         mContext = spy(RuntimeEnvironment.application);
 102         ReflectionHelpers.setField(mPolicy, "wakeupAlarmThreshold", 60);
 103
 104         doReturn(false).when(mBatteryUtils).shouldHideSipper(any());
 105         doReturn(RUNNING_TIME_MS).when(mBatteryUtils).calculateRunningTimeBasedOnStatsType(any(),
 106                 anyInt());
 107         doReturn(true).when(mAnomalyAction).isActionActive(any());
 108
 109         mAnomalySipper.uidObj = mAnomalyUid;
 110         doReturn(ANOMALY_UID).when(mAnomalyUid).getUid();
 111         mNormalSipper.uidObj = mNormalUid;
 112         doReturn(NORMAL_UID).when(mNormalUid).getUid();
 113         mTargetSipper.uidObj = mTargetUid;
 114         doReturn(TARGET_UID).when(mTargetUid).getUid();
 115
 116         mUsageList = new ArrayList<>();
 117         mUsageList.add(mAnomalySipper);
 118         mUsageList.add(mNormalSipper);
 119         mUsageList.add(mTargetSipper);
 120         doReturn(mUsageList).when(mBatteryStatsHelper).getUsageList();
 121
 122         mWakeupAlarmAnomalyDetector = spy(new WakeupAlarmAnomalyDetector(mContext, mPolicy));
 123         mWakeupAlarmAnomalyDetector.mBatteryUtils = mBatteryUtils;
 124         mWakeupAlarmAnomalyDetector.mAnomalyAction = mAnomalyAction;
 125     }
 126
 127     @Test
 128     public void testDetectAnomalies_containsAnomaly_detectIt() {
 129         doReturn(-1).when(mBatteryUtils).getPackageUid(nullable(String.class));
 130         doReturn(ANOMALY_WAKEUP_COUNT).when(mWakeupAlarmAnomalyDetector).getWakeupAlarmCountFromUid(
 131                 mAnomalyUid);
 132         doReturn(ANOMALY_WAKEUP_COUNT).when(mWakeupAlarmAnomalyDetector).getWakeupAlarmCountFromUid(
 133                 mTargetUid);
 134         doReturn(NORMAL_WAKEUP_COUNT).when(mWakeupAlarmAnomalyDetector).getWakeupAlarmCountFromUid(
 135                 mNormalUid);
 136         final Anomaly anomaly = new Anomaly.Builder()
 137                 .setUid(ANOMALY_UID)
 138                 .setType(Anomaly.AnomalyType.WAKEUP_ALARM)
 139                 .build();
 140         final Anomaly targetAnomaly = new Anomaly.Builder()
 141                 .setUid(TARGET_UID)
 142                 .setType(Anomaly.AnomalyType.WAKEUP_ALARM)
 143                 .build();
 144
 145         List<Anomaly> mAnomalies = mWakeupAlarmAnomalyDetector.detectAnomalies(mBatteryStatsHelper);
 146
 147         assertThat(mAnomalies).containsExactly(anomaly, targetAnomaly);
 148     }
 149
 150     @Test
 151     public void testDetectAnomalies_detectTargetAnomaly_detectIt() {
 152         doReturn(TARGET_UID).when(mBatteryUtils).getPackageUid(TARGET_PACKAGE_NAME);
 153         doReturn(ANOMALY_WAKEUP_COUNT).when(mWakeupAlarmAnomalyDetector).getWakeupAlarmCountFromUid(
 154                 mAnomalyUid);
 155         doReturn(ANOMALY_WAKEUP_COUNT).when(mWakeupAlarmAnomalyDetector).getWakeupAlarmCountFromUid(
 156                 mTargetUid);
 157         doReturn(NORMAL_WAKEUP_COUNT).when(mWakeupAlarmAnomalyDetector).getWakeupAlarmCountFromUid(
 158                 mNormalUid);
 159         final Anomaly targetAnomaly = new Anomaly.Builder()
 160                 .setUid(TARGET_UID)
 161                 .setType(Anomaly.AnomalyType.WAKEUP_ALARM)
 162                 .build();
 163
 164         List<Anomaly> mAnomalies = mWakeupAlarmAnomalyDetector.detectAnomalies(mBatteryStatsHelper,
 165                 TARGET_PACKAGE_NAME);
 166
 167         assertThat(mAnomalies).containsExactly(targetAnomaly);
 168     }
 169
 170     @Test
 171     public void testGetWakeupAlarmCountFromUid_countCorrect() {
 172         final ArrayMap<String, BatteryStats.Uid.Pkg> packageStats = new ArrayMap<>();
 173         final ArrayMap<String, BatteryStats.Counter> alarms = new ArrayMap<>();
 174         doReturn(alarms).when(mPkg).getWakeupAlarmStats();
 175         doReturn(NORMAL_WAKEUP_COUNT).when(mCounter).getCountLocked(anyInt());
 176         doReturn(packageStats).when(mAnomalyUid).getPackageStats();
 177         packageStats.put("", mPkg);
 178         alarms.put("1", mCounter);
 179         alarms.put("2", mCounter);
 180
 181         assertThat(mWakeupAlarmAnomalyDetector.getWakeupAlarmCountFromUid(mAnomalyUid)).isEqualTo(
 182                 2 * NORMAL_WAKEUP_COUNT);
 183     }
 184 }