Home | History | Annotate | Download | only in fuelgauge 
      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;
     18 
     19 import static com.google.common.truth.Truth.assertThat;
     20 import static org.mockito.Mockito.doReturn;
     21 import static org.mockito.Mockito.spy;
     22 import static org.mockito.Mockito.when;
     23 
     24 import android.content.Context;
     25 import android.support.v7.preference.PreferenceGroup;
     26 import android.text.TextUtils;
     27 import android.text.format.DateUtils;
     28 import android.util.FeatureFlagUtils;
     29 import android.util.SparseArray;
     30 
     31 import com.android.internal.os.BatterySipper;
     32 import com.android.internal.os.BatteryStatsImpl;
     33 import com.android.settings.R;
     34 import com.android.settings.SettingsActivity;
     35 import com.android.settings.core.FeatureFlags;
     36 import com.android.settings.core.InstrumentedPreferenceFragment;
     37 import com.android.settings.fuelgauge.anomaly.Anomaly;
     38 import com.android.settings.testutils.FakeFeatureFactory;
     39 
     40 import org.junit.Before;
     41 import org.junit.Test;
     42 import org.junit.runner.RunWith;
     43 import org.mockito.Mock;
     44 import org.mockito.MockitoAnnotations;
     45 import org.robolectric.RobolectricTestRunner;
     46 import org.robolectric.RuntimeEnvironment;
     47 
     48 import java.util.List;
     49 
     50 @RunWith(RobolectricTestRunner.class)
     51 public class BatteryAppListPreferenceControllerTest {
     52 
     53     private static final String[] PACKAGE_NAMES = {"com.app1", "com.app2"};
     54     private static final String KEY_APP_LIST = "app_list";
     55     private static final int UID = 123;
     56 
     57     @Mock
     58     private BatterySipper mNormalBatterySipper;
     59     @Mock
     60     private SettingsActivity mSettingsActivity;
     61     @Mock
     62     private PreferenceGroup mAppListGroup;
     63     @Mock
     64     private InstrumentedPreferenceFragment mFragment;
     65     @Mock
     66     private BatteryUtils mBatteryUtils;
     67 
     68     private Context mContext;
     69     private PowerGaugePreference mPreference;
     70     private BatteryAppListPreferenceController mPreferenceController;
     71 
     72     @Before
     73     public void setUp() {
     74         MockitoAnnotations.initMocks(this);
     75 
     76         mContext = spy(RuntimeEnvironment.application);
     77         FakeFeatureFactory.setupForTest();
     78 
     79         mPreference = new PowerGaugePreference(mContext);
     80         when(mNormalBatterySipper.getPackages()).thenReturn(PACKAGE_NAMES);
     81         when(mNormalBatterySipper.getUid()).thenReturn(UID);
     82         mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
     83 
     84         mPreferenceController = new BatteryAppListPreferenceController(mContext, KEY_APP_LIST, null,
     85                 mSettingsActivity, mFragment);
     86         mPreferenceController.mBatteryUtils = mBatteryUtils;
     87         mPreferenceController.mAppListGroup = mAppListGroup;
     88     }
     89 
     90     @Test
     91     public void testExtractKeyFromSipper_typeAPPUidObjectNull_returnPackageNames() {
     92         mNormalBatterySipper.uidObj = null;
     93         mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
     94 
     95         final String key = mPreferenceController.extractKeyFromSipper(mNormalBatterySipper);
     96         assertThat(key).isEqualTo(TextUtils.concat(mNormalBatterySipper.getPackages()).toString());
     97     }
     98 
     99     @Test
    100     public void testExtractKeyFromSipper_typeOther_returnDrainType() {
    101         mNormalBatterySipper.uidObj = null;
    102         mNormalBatterySipper.drainType = BatterySipper.DrainType.BLUETOOTH;
    103 
    104         final String key = mPreferenceController.extractKeyFromSipper(mNormalBatterySipper);
    105         assertThat(key).isEqualTo(mNormalBatterySipper.drainType.toString());
    106     }
    107 
    108     @Test
    109     public void testExtractKeyFromSipper_typeUser_returnDrainTypeWithUserId() {
    110         mNormalBatterySipper.uidObj = null;
    111         mNormalBatterySipper.drainType = BatterySipper.DrainType.USER;
    112         mNormalBatterySipper.userId = 2;
    113 
    114         final String key = mPreferenceController.extractKeyFromSipper(mNormalBatterySipper);
    115         assertThat(key).isEqualTo("USER2");
    116     }
    117 
    118     @Test
    119     public void testExtractKeyFromSipper_typeAPPUidObjectNotNull_returnUid() {
    120         mNormalBatterySipper.uidObj = new BatteryStatsImpl.Uid(new BatteryStatsImpl(), UID);
    121         mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
    122 
    123         final String key = mPreferenceController.extractKeyFromSipper(mNormalBatterySipper);
    124         assertThat(key).isEqualTo(Integer.toString(mNormalBatterySipper.getUid()));
    125     }
    126 
    127     @Test
    128     public void testSetUsageSummary_timeLessThanOneMinute_DoNotSetSummary() {
    129         mNormalBatterySipper.usageTimeMs = 59 * DateUtils.SECOND_IN_MILLIS;
    130 
    131         mPreferenceController.setUsageSummary(mPreference, mNormalBatterySipper);
    132         assertThat(mPreference.getSummary()).isNull();
    133     }
    134 
    135     @Test
    136     public void testSetUsageSummary_timeMoreThanOneMinute_normalApp_setScreenSummary() {
    137         mNormalBatterySipper.usageTimeMs = 2 * DateUtils.MINUTE_IN_MILLIS;
    138         doReturn(mContext.getText(R.string.battery_used_for)).when(mFragment).getText(
    139                 R.string.battery_used_for);
    140         doReturn(mContext).when(mFragment).getContext();
    141 
    142         mPreferenceController.setUsageSummary(mPreference, mNormalBatterySipper);
    143 
    144         assertThat(mPreference.getSummary().toString()).isEqualTo("Used for 2 min");
    145     }
    146 
    147     @Test
    148     public void testSetUsageSummary_timeMoreThanOneMinute_hiddenApp_setUsedSummary() {
    149         mNormalBatterySipper.usageTimeMs = 2 * DateUtils.MINUTE_IN_MILLIS;
    150         doReturn(true).when(mBatteryUtils).shouldHideSipper(mNormalBatterySipper);
    151         doReturn(mContext).when(mFragment).getContext();
    152 
    153         mPreferenceController.setUsageSummary(mPreference, mNormalBatterySipper);
    154 
    155         assertThat(mPreference.getSummary().toString()).isEqualTo("2 min");
    156     }
    157 
    158     @Test
    159     public void testSetUsageSummary_timeMoreThanOneMinute_notApp_setUsedSummary() {
    160         mNormalBatterySipper.usageTimeMs = 2 * DateUtils.MINUTE_IN_MILLIS;
    161         mNormalBatterySipper.drainType = BatterySipper.DrainType.PHONE;
    162         doReturn(mContext).when(mFragment).getContext();
    163 
    164         mPreferenceController.setUsageSummary(mPreference, mNormalBatterySipper);
    165 
    166         assertThat(mPreference.getSummary().toString()).isEqualTo("2 min");
    167     }
    168 
    169     @Test
    170     public void testRefreshAnomalyIcon_containsAnomaly_showAnomalyIcon() {
    171         FeatureFlagUtils.setEnabled(mContext, FeatureFlags.BATTERY_DISPLAY_APP_LIST, true);
    172         PowerGaugePreference preference = new PowerGaugePreference(mContext);
    173         final String key = mPreferenceController.extractKeyFromUid(UID);
    174         final SparseArray<List<Anomaly>> anomalySparseArray = new SparseArray<>();
    175         anomalySparseArray.append(UID, null);
    176         preference.setKey(key);
    177         doReturn(preference).when(mAppListGroup).findPreference(key);
    178 
    179         mPreferenceController.refreshAnomalyIcon(anomalySparseArray);
    180 
    181         assertThat(preference.showAnomalyIcon()).isTrue();
    182     }
    183 
    184     @Test
    185     public void testShouldHideSipper_typeOvercounted_returnTrue() {
    186         mNormalBatterySipper.drainType = BatterySipper.DrainType.OVERCOUNTED;
    187 
    188         assertThat(mPreferenceController.shouldHideSipper(mNormalBatterySipper)).isTrue();
    189     }
    190 
    191     @Test
    192     public void testShouldHideSipper_typeUnaccounted_returnTrue() {
    193         mNormalBatterySipper.drainType = BatterySipper.DrainType.UNACCOUNTED;
    194 
    195         assertThat(mPreferenceController.shouldHideSipper(mNormalBatterySipper)).isTrue();
    196     }
    197 
    198     @Test
    199     public void testShouldHideSipper_typeNormal_returnFalse() {
    200         mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
    201 
    202         assertThat(mPreferenceController.shouldHideSipper(mNormalBatterySipper)).isFalse();
    203     }
    204 
    205     @Test
    206     public void testNeverUseFakeData() {
    207         assertThat(BatteryAppListPreferenceController.USE_FAKE_DATA).isFalse();
    208     }
    209 }
    210