Merge "Remove the old battery page" into pi-dev am: 4e25277f60
am: 71333cb477
Change-Id: I166c6de0bd2a7150dbfbbe35783c2fab86c6ed45
This commit is contained in:
Lei Yu
android-build-merger
@@ -4,7 +4,6 @@ com.android.settings.bluetooth.BluetoothDeviceDetailsFragment
|
||||
com.android.settings.bluetooth.BluetoothPairingDetail
|
||||
com.android.settings.accounts.AccountDetailDashboardFragment
|
||||
com.android.settings.fuelgauge.PowerUsageAnomalyDetails
|
||||
com.android.settings.fuelgauge.PowerUsageSummaryLegacy
|
||||
com.android.settings.fuelgauge.AdvancedPowerUsageDetail
|
||||
com.android.settings.development.featureflags.FeatureFlagsDashboard
|
||||
com.android.settings.development.qstile.DevelopmentTileConfigFragment
|
||||
|
||||
@@ -1,437 +0,0 @@
|
||||
/*
|
||||
* 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;
|
||||
|
||||
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.atLeastOnce;
|
||||
import static org.mockito.Mockito.doReturn;
|
||||
import static org.mockito.Mockito.never;
|
||||
import static org.mockito.Mockito.spy;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import android.content.Context;
|
||||
import android.content.Intent;
|
||||
import android.content.pm.PackageManager;
|
||||
import android.content.pm.UserInfo;
|
||||
import android.net.ConnectivityManager;
|
||||
import android.os.UserManager;
|
||||
import android.support.v7.preference.PreferenceCategory;
|
||||
import android.support.v7.preference.PreferenceGroup;
|
||||
import android.support.v7.preference.PreferenceManager;
|
||||
|
||||
import com.android.internal.os.BatterySipper;
|
||||
import com.android.internal.os.BatterySipper.DrainType;
|
||||
import com.android.internal.os.BatteryStatsHelper;
|
||||
import com.android.settings.R;
|
||||
import com.android.settings.Utils;
|
||||
import com.android.settings.testutils.BatteryTestUtils;
|
||||
import com.android.settings.testutils.SettingsRobolectricTestRunner;
|
||||
import com.android.settings.fuelgauge.PowerUsageAdvancedLegacy.PowerUsageData;
|
||||
import com.android.settings.fuelgauge.PowerUsageAdvancedLegacy.PowerUsageData.UsageType;
|
||||
|
||||
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.RuntimeEnvironment;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
@RunWith(SettingsRobolectricTestRunner.class)
|
||||
public class PowerUsageAdvancedLegacyTest {
|
||||
private static final int FAKE_UID_1 = 50;
|
||||
private static final int FAKE_UID_2 = 100;
|
||||
private static final int DISCHARGE_AMOUNT = 60;
|
||||
private static final double TYPE_APP_USAGE = 80;
|
||||
private static final double TYPE_BLUETOOTH_USAGE = 50;
|
||||
private static final double TYPE_WIFI_USAGE = 0;
|
||||
private static final double TOTAL_USAGE = TYPE_APP_USAGE * 2 + TYPE_BLUETOOTH_USAGE
|
||||
+ TYPE_WIFI_USAGE;
|
||||
private static final double TOTAL_POWER = 500;
|
||||
private static final double PRECISION = 0.001;
|
||||
private static final String STUB_STRING = "stub_string";
|
||||
@Mock
|
||||
private BatterySipper mNormalBatterySipper;
|
||||
@Mock
|
||||
private BatterySipper mMaxBatterySipper;
|
||||
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
|
||||
private BatteryStatsHelper mBatteryStatsHelper;
|
||||
@Mock
|
||||
private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
|
||||
@Mock
|
||||
private PackageManager mPackageManager;
|
||||
@Mock
|
||||
private UserManager mUserManager;
|
||||
@Mock
|
||||
private BatteryHistoryPreference mHistPref;
|
||||
@Mock
|
||||
private PreferenceGroup mUsageListGroup;
|
||||
@Mock
|
||||
private ConnectivityManager mConnectivityManager;
|
||||
@Mock
|
||||
private UserInfo mNormalUserInfo;
|
||||
@Mock
|
||||
private UserInfo mManagedUserInfo;
|
||||
private PowerUsageAdvancedLegacy mPowerUsageAdvanced;
|
||||
private PowerUsageData mPowerUsageData;
|
||||
private Context mShadowContext;
|
||||
private Intent mDischargingBatteryIntent;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
MockitoAnnotations.initMocks(this);
|
||||
mShadowContext = spy(RuntimeEnvironment.application);
|
||||
mPowerUsageAdvanced = spy(new PowerUsageAdvancedLegacy());
|
||||
|
||||
List<BatterySipper> batterySippers = new ArrayList<>();
|
||||
batterySippers.add(new BatterySipper(DrainType.APP,
|
||||
new FakeUid(FAKE_UID_1), TYPE_APP_USAGE));
|
||||
batterySippers.add(new BatterySipper(DrainType.APP,
|
||||
new FakeUid(FAKE_UID_2), TYPE_APP_USAGE));
|
||||
batterySippers.add(new BatterySipper(DrainType.BLUETOOTH, new FakeUid(FAKE_UID_1),
|
||||
TYPE_BLUETOOTH_USAGE));
|
||||
batterySippers.add(new BatterySipper(DrainType.WIFI, new FakeUid(FAKE_UID_1),
|
||||
TYPE_WIFI_USAGE));
|
||||
|
||||
mDischargingBatteryIntent = BatteryTestUtils.getDischargingIntent();
|
||||
doReturn(mDischargingBatteryIntent).when(mShadowContext).registerReceiver(any(), any());
|
||||
when(mBatteryStatsHelper.getStats().getDischargeAmount(anyInt())).thenReturn(
|
||||
DISCHARGE_AMOUNT);
|
||||
when(mBatteryStatsHelper.getUsageList()).thenReturn(batterySippers);
|
||||
when(mBatteryStatsHelper.getTotalPower()).thenReturn(TOTAL_USAGE);
|
||||
when(mPowerUsageAdvanced.getContext()).thenReturn(mShadowContext);
|
||||
doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any(), any());
|
||||
doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any());
|
||||
doReturn(mShadowContext.getText(R.string.battery_used_for)).when(
|
||||
mPowerUsageAdvanced).getText(R.string.battery_used_for);
|
||||
mPowerUsageAdvanced.setPackageManager(mPackageManager);
|
||||
mPowerUsageAdvanced.setPowerUsageFeatureProvider(mPowerUsageFeatureProvider);
|
||||
mPowerUsageAdvanced.setUserManager(mUserManager);
|
||||
mPowerUsageAdvanced.setBatteryUtils(BatteryUtils.getInstance(mShadowContext));
|
||||
when(mShadowContext.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(
|
||||
mConnectivityManager);
|
||||
|
||||
mPowerUsageData = new PowerUsageData(UsageType.USER);
|
||||
mMaxBatterySipper.totalPowerMah = TYPE_BLUETOOTH_USAGE;
|
||||
mMaxBatterySipper.drainType = DrainType.BLUETOOTH;
|
||||
mNormalBatterySipper.drainType = DrainType.SCREEN;
|
||||
|
||||
doReturn(true).when(mNormalUserInfo).isEnabled();
|
||||
doReturn(false).when(mNormalUserInfo).isManagedProfile();
|
||||
doReturn(true).when(mManagedUserInfo).isEnabled();
|
||||
doReturn(true).when(mManagedUserInfo).isManagedProfile();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPrefs_shouldNotBeSelectable() {
|
||||
PreferenceManager pm = new PreferenceManager(mShadowContext);
|
||||
when(mPowerUsageAdvanced.getPreferenceManager()).thenReturn(pm);
|
||||
PreferenceGroup prefGroup = spy(new PreferenceCategory(mShadowContext));
|
||||
when(prefGroup.getPreferenceManager()).thenReturn(pm);
|
||||
|
||||
mPowerUsageAdvanced.refreshPowerUsageDataList(mBatteryStatsHelper, prefGroup);
|
||||
assertThat(prefGroup.getPreferenceCount()).isAtLeast(1);
|
||||
for (int i = 0, count = prefGroup.getPreferenceCount(); i < count; i++) {
|
||||
PowerGaugePreference pref = (PowerGaugePreference) prefGroup.getPreference(i);
|
||||
assertThat(pref.isSelectable()).isFalse();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractUsageType_TypeSystem_ReturnSystem() {
|
||||
mNormalBatterySipper.drainType = DrainType.APP;
|
||||
when(mPowerUsageFeatureProvider.isTypeSystem(any())).thenReturn(true);
|
||||
|
||||
assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
|
||||
.isEqualTo(UsageType.SYSTEM);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractUsageType_TypeEqualsToDrainType_ReturnRelevantType() {
|
||||
final DrainType drainTypes[] = {DrainType.WIFI, DrainType.BLUETOOTH, DrainType.IDLE,
|
||||
DrainType.USER, DrainType.CELL, DrainType.UNACCOUNTED};
|
||||
final int usageTypes[] = {UsageType.WIFI, UsageType.BLUETOOTH, UsageType.IDLE,
|
||||
UsageType.USER, UsageType.CELL, UsageType.UNACCOUNTED};
|
||||
|
||||
assertThat(drainTypes.length).isEqualTo(usageTypes.length);
|
||||
for (int i = 0, size = drainTypes.length; i < size; i++) {
|
||||
mNormalBatterySipper.drainType = drainTypes[i];
|
||||
assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
|
||||
.isEqualTo(usageTypes[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractUsageType_TypeService_ReturnSystem() {
|
||||
mNormalBatterySipper.drainType = DrainType.APP;
|
||||
when(mNormalBatterySipper.getUid()).thenReturn(FAKE_UID_1);
|
||||
when(mPowerUsageFeatureProvider.isTypeService(any())).thenReturn(true);
|
||||
|
||||
assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
|
||||
.isEqualTo(UsageType.SYSTEM);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParsePowerUsageData_PercentageCalculatedCorrectly() {
|
||||
final double percentApp = TYPE_APP_USAGE * 2 / TOTAL_USAGE * DISCHARGE_AMOUNT;
|
||||
final double percentWifi = TYPE_WIFI_USAGE / TOTAL_USAGE * DISCHARGE_AMOUNT;
|
||||
final double percentBluetooth = TYPE_BLUETOOTH_USAGE / TOTAL_USAGE * DISCHARGE_AMOUNT;
|
||||
|
||||
List<PowerUsageData> batteryData =
|
||||
mPowerUsageAdvanced.parsePowerUsageData(mBatteryStatsHelper);
|
||||
for (PowerUsageData data : batteryData) {
|
||||
switch (data.usageType) {
|
||||
case UsageType.WIFI:
|
||||
assertThat(data.percentage).isWithin(PRECISION).of(percentWifi);
|
||||
break;
|
||||
case UsageType.APP:
|
||||
assertThat(data.percentage).isWithin(PRECISION).of(percentApp);
|
||||
break;
|
||||
case UsageType.BLUETOOTH:
|
||||
assertThat(data.percentage).isWithin(PRECISION).of(percentBluetooth);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateUsageDataSummary_onlyOneApp_showUsageTime() {
|
||||
final String expectedSummary = "Used for 0m";
|
||||
mPowerUsageData.usageList.add(mNormalBatterySipper);
|
||||
|
||||
mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
|
||||
|
||||
assertThat(mPowerUsageData.summary.toString()).isEqualTo(expectedSummary);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateUsageDataSummary_typeIdle_showUsageTime() {
|
||||
mPowerUsageData.usageType = UsageType.IDLE;
|
||||
mPowerUsageData.usageList.add(mNormalBatterySipper);
|
||||
|
||||
mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
|
||||
|
||||
assertThat(mPowerUsageData.summary.toString()).isEqualTo("0m");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateUsageDataSummary_moreThanOneApp_showMaxUsageApp() {
|
||||
mPowerUsageData.usageList.add(mNormalBatterySipper);
|
||||
mPowerUsageData.usageList.add(mMaxBatterySipper);
|
||||
doReturn(mMaxBatterySipper).when(mPowerUsageAdvanced)
|
||||
.findBatterySipperWithMaxBatteryUsage(mPowerUsageData.usageList);
|
||||
final double percentage = (TYPE_BLUETOOTH_USAGE / TOTAL_POWER) * DISCHARGE_AMOUNT;
|
||||
mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
|
||||
|
||||
verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_by),
|
||||
eq(Utils.formatPercentage(percentage, true)), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindBatterySipperWithMaxBatteryUsage_findCorrectOne() {
|
||||
mPowerUsageData.usageList.add(mNormalBatterySipper);
|
||||
mPowerUsageData.usageList.add(mMaxBatterySipper);
|
||||
BatterySipper sipper =
|
||||
mPowerUsageAdvanced.findBatterySipperWithMaxBatteryUsage(mPowerUsageData.usageList);
|
||||
|
||||
assertThat(sipper).isEqualTo(mMaxBatterySipper);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInit_ContainsAllUsageType() {
|
||||
final int[] usageTypeSet = mPowerUsageAdvanced.mUsageTypes;
|
||||
|
||||
assertThat(usageTypeSet).asList().containsExactly(UsageType.APP, UsageType.WIFI,
|
||||
UsageType.CELL, UsageType.BLUETOOTH, UsageType.IDLE, UsageType.USER,
|
||||
UsageType.SYSTEM, UsageType.UNACCOUNTED, UsageType.OVERCOUNTED);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPowerUsageData_SortedByUsage() {
|
||||
List<PowerUsageData> dataList = new ArrayList<>();
|
||||
|
||||
dataList.add(new PowerUsageData(UsageType.WIFI, TYPE_WIFI_USAGE));
|
||||
dataList.add(new PowerUsageData(UsageType.BLUETOOTH, TYPE_BLUETOOTH_USAGE));
|
||||
dataList.add(new PowerUsageData(UsageType.APP, TYPE_APP_USAGE));
|
||||
Collections.sort(dataList);
|
||||
|
||||
for (int i = 1, size = dataList.size(); i < size; i++) {
|
||||
assertThat(dataList.get(i - 1).totalPowerMah).isAtLeast(dataList.get(i).totalPowerMah);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeUnAccounted_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.UNACCOUNTED;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeOverCounted_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.OVERCOUNTED;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeUserAndOnlyOneNormalUser_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.USER;
|
||||
List<UserInfo> userInfos = new ArrayList<>();
|
||||
userInfos.add(mNormalUserInfo);
|
||||
userInfos.add(mManagedUserInfo);
|
||||
doReturn(userInfos).when(mUserManager).getUsers();
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeCellWhileNotSupported_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.CELL;
|
||||
doReturn(false).when(mConnectivityManager)
|
||||
.isNetworkSupported(ConnectivityManager.TYPE_MOBILE);
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeCellWhileSupported_returnFalse() {
|
||||
mPowerUsageData.usageType = UsageType.CELL;
|
||||
doReturn(true).when(mConnectivityManager).isNetworkSupported(
|
||||
ConnectivityManager.TYPE_MOBILE);
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeUserAndMoreThanOne_returnFalse() {
|
||||
mPowerUsageData.usageType = UsageType.USER;
|
||||
List<UserInfo> userInfos = new ArrayList<>();
|
||||
userInfos.add(mNormalUserInfo);
|
||||
userInfos.add(mNormalUserInfo);
|
||||
doReturn(userInfos).when(mUserManager).getUsers();
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideCategory_typeNormal_returnFalse() {
|
||||
mPowerUsageData.usageType = UsageType.APP;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSummary_typeCell_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.CELL;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSummary_typeSystem_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.SYSTEM;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSummary_typeWifi_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.WIFI;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSummary_typeBluetooth_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.BLUETOOTH;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSummary_typeApp_returnTrue() {
|
||||
mPowerUsageData.usageType = UsageType.APP;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSummary_typeNormal_returnFalse() {
|
||||
mPowerUsageData.usageType = UsageType.IDLE;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldShowBatterySipper_typeScreen_returnFalse() {
|
||||
mNormalBatterySipper.drainType = DrainType.SCREEN;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldShowBatterySipper_typeNormal_returnTrue() {
|
||||
mNormalBatterySipper.drainType = DrainType.APP;
|
||||
|
||||
assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateHiddenPower_returnCorrectPower() {
|
||||
List<PowerUsageData> powerUsageDataList = new ArrayList<>();
|
||||
final double unaccountedPower = 100;
|
||||
final double normalPower = 150;
|
||||
powerUsageDataList.add(new PowerUsageData(UsageType.UNACCOUNTED, unaccountedPower));
|
||||
powerUsageDataList.add(new PowerUsageData(UsageType.APP, normalPower));
|
||||
powerUsageDataList.add(new PowerUsageData(UsageType.CELL, normalPower));
|
||||
|
||||
assertThat(mPowerUsageAdvanced.calculateHiddenPower(powerUsageDataList))
|
||||
.isWithin(PRECISION).of(unaccountedPower);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRefreshUi_addsSubtextWhenAppropriate() {
|
||||
// Mock out all the battery stuff
|
||||
mPowerUsageAdvanced.mHistPref = mHistPref;
|
||||
mPowerUsageAdvanced.mStatsHelper = mBatteryStatsHelper;
|
||||
doReturn(new ArrayList<PowerUsageData>())
|
||||
.when(mPowerUsageAdvanced).parsePowerUsageData(any());
|
||||
doReturn("").when(mPowerUsageAdvanced).getString(anyInt());
|
||||
mPowerUsageAdvanced.mUsageListGroup = mUsageListGroup;
|
||||
|
||||
// refresh the ui and check that text was not updated when enhanced prediction disabled
|
||||
when(mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(any()))
|
||||
.thenReturn(false);
|
||||
mPowerUsageAdvanced.refreshUi();
|
||||
verify(mHistPref, never()).setBottomSummary(any());
|
||||
|
||||
// refresh the ui and check that text was updated when enhanced prediction enabled
|
||||
when(mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(any())).thenReturn(true);
|
||||
mPowerUsageAdvanced.refreshUi();
|
||||
verify(mHistPref, atLeastOnce()).setBottomSummary(any());
|
||||
}
|
||||
}
|
||||
@@ -1,541 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2016 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;
|
||||
|
||||
import static com.android.settings.fuelgauge.PowerUsageSummaryLegacy.MENU_HIGH_POWER_APPS;
|
||||
import static com.android.settings.fuelgauge.PowerUsageSummaryLegacy.MENU_TOGGLE_APPS;
|
||||
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.anyLong;
|
||||
import static org.mockito.Matchers.eq;
|
||||
import static org.mockito.Mockito.doNothing;
|
||||
import static org.mockito.Mockito.doReturn;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.never;
|
||||
import static org.mockito.Mockito.spy;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import android.app.LoaderManager;
|
||||
import android.content.Context;
|
||||
import android.content.Intent;
|
||||
import android.os.Bundle;
|
||||
import android.support.v7.preference.PreferenceGroup;
|
||||
import android.support.v7.preference.PreferenceScreen;
|
||||
import android.text.TextUtils;
|
||||
import android.text.format.DateUtils;
|
||||
import android.util.SparseArray;
|
||||
import android.view.Menu;
|
||||
import android.view.MenuInflater;
|
||||
import android.view.MenuItem;
|
||||
import android.view.View;
|
||||
import android.widget.TextView;
|
||||
|
||||
import com.android.internal.logging.nano.MetricsProto;
|
||||
import com.android.internal.os.BatterySipper;
|
||||
import com.android.internal.os.BatteryStatsHelper;
|
||||
import com.android.internal.os.BatteryStatsImpl;
|
||||
import com.android.settings.R;
|
||||
import com.android.settings.SettingsActivity;
|
||||
import com.android.settings.applications.LayoutPreference;
|
||||
import com.android.settings.fuelgauge.anomaly.Anomaly;
|
||||
import com.android.settings.fuelgauge.anomaly.AnomalyDetectionPolicy;
|
||||
import com.android.settings.testutils.FakeFeatureFactory;
|
||||
import com.android.settings.testutils.SettingsRobolectricTestRunner;
|
||||
import com.android.settings.testutils.XmlTestUtils;
|
||||
import com.android.settings.testutils.shadow.SettingsShadowResources;
|
||||
import com.android.settingslib.core.AbstractPreferenceController;
|
||||
import com.android.settingslib.utils.StringUtil;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Answers;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
import org.robolectric.RuntimeEnvironment;
|
||||
import org.robolectric.annotation.Config;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
// TODO: Improve this test class so that it starts up the real activity and fragment.
|
||||
@RunWith(SettingsRobolectricTestRunner.class)
|
||||
@Config(shadows = {
|
||||
SettingsShadowResources.class,
|
||||
SettingsShadowResources.SettingsShadowTheme.class,
|
||||
})
|
||||
public class PowerUsageSummaryLegacyTest {
|
||||
|
||||
private static final String[] PACKAGE_NAMES = {"com.app1", "com.app2"};
|
||||
private static final String STUB_STRING = "stub_string";
|
||||
private static final int UID = 123;
|
||||
private static final int UID_2 = 234;
|
||||
private static final int POWER_MAH = 100;
|
||||
private static final long TIME_SINCE_LAST_FULL_CHARGE_MS = 120 * 60 * 1000;
|
||||
private static final long TIME_SINCE_LAST_FULL_CHARGE_US =
|
||||
TIME_SINCE_LAST_FULL_CHARGE_MS * 1000;
|
||||
private static final int DISCHARGE_AMOUNT = 100;
|
||||
private static final long USAGE_TIME_MS = 65 * 60 * 1000;
|
||||
private static final double TOTAL_POWER = 200;
|
||||
private static final double PRECISION = 0.001;
|
||||
private static final double POWER_USAGE_PERCENTAGE = 50;
|
||||
private static final String NEW_ML_EST_SUFFIX = "(New ML est)";
|
||||
private static final String OLD_EST_SUFFIX = "(Old est)";
|
||||
private static Intent sAdditionalBatteryInfoIntent;
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() {
|
||||
sAdditionalBatteryInfoIntent =new Intent("com.example.app.ADDITIONAL_BATTERY_INFO");
|
||||
}
|
||||
|
||||
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
|
||||
private Menu mMenu;
|
||||
@Mock
|
||||
private MenuItem mToggleAppsMenu;
|
||||
@Mock
|
||||
private MenuItem mHighPowerMenu;
|
||||
@Mock
|
||||
private MenuInflater mMenuInflater;
|
||||
@Mock
|
||||
private BatterySipper mNormalBatterySipper;
|
||||
@Mock
|
||||
private BatterySipper mScreenBatterySipper;
|
||||
@Mock
|
||||
private BatterySipper mCellBatterySipper;
|
||||
@Mock
|
||||
private LayoutPreference mBatteryLayoutPref;
|
||||
@Mock
|
||||
private TextView mBatteryPercentText;
|
||||
@Mock
|
||||
private TextView mSummary1;
|
||||
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
|
||||
private BatteryStatsHelper mBatteryHelper;
|
||||
@Mock
|
||||
private SettingsActivity mSettingsActivity;
|
||||
@Mock
|
||||
private LoaderManager mLoaderManager;
|
||||
@Mock
|
||||
private PreferenceScreen mPreferenceScreen;
|
||||
@Mock
|
||||
private PreferenceGroup mAppListGroup;
|
||||
@Mock
|
||||
private AnomalyDetectionPolicy mAnomalyDetectionPolicy;
|
||||
@Mock
|
||||
private BatteryHeaderPreferenceController mBatteryHeaderPreferenceController;
|
||||
|
||||
private List<BatterySipper> mUsageList;
|
||||
private Context mRealContext;
|
||||
private TestFragment mFragment;
|
||||
private FakeFeatureFactory mFeatureFactory;
|
||||
private BatteryMeterView mBatteryMeterView;
|
||||
private PowerGaugePreference mPreference;
|
||||
private PowerGaugePreference mScreenUsagePref;
|
||||
private PowerGaugePreference mLastFullChargePref;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
MockitoAnnotations.initMocks(this);
|
||||
|
||||
mRealContext = RuntimeEnvironment.application;
|
||||
mFeatureFactory = FakeFeatureFactory.setupForTest();
|
||||
|
||||
mPreference = new PowerGaugePreference(mRealContext);
|
||||
mScreenUsagePref = new PowerGaugePreference(mRealContext);
|
||||
mLastFullChargePref = new PowerGaugePreference(mRealContext);
|
||||
mFragment = spy(new TestFragment(mRealContext));
|
||||
mFragment.initFeatureProvider();
|
||||
mBatteryMeterView = new BatteryMeterView(mRealContext);
|
||||
mBatteryMeterView.mDrawable = new BatteryMeterView.BatteryMeterDrawable(mRealContext, 0);
|
||||
doNothing().when(mFragment).restartBatteryStatsLoader();
|
||||
doReturn(mock(LoaderManager.class)).when(mFragment).getLoaderManager();
|
||||
|
||||
when(mFragment.getActivity()).thenReturn(mSettingsActivity);
|
||||
when(mToggleAppsMenu.getItemId()).thenReturn(MENU_TOGGLE_APPS);
|
||||
when(mHighPowerMenu.getItemId()).thenReturn(MENU_HIGH_POWER_APPS);
|
||||
when(mFeatureFactory.powerUsageFeatureProvider.getAdditionalBatteryInfoIntent())
|
||||
.thenReturn(sAdditionalBatteryInfoIntent);
|
||||
when(mBatteryHelper.getTotalPower()).thenReturn(TOTAL_POWER);
|
||||
when(mBatteryHelper.getStats().computeBatteryRealtime(anyLong(), anyInt()))
|
||||
.thenReturn(TIME_SINCE_LAST_FULL_CHARGE_US);
|
||||
|
||||
when(mNormalBatterySipper.getPackages()).thenReturn(PACKAGE_NAMES);
|
||||
when(mNormalBatterySipper.getUid()).thenReturn(UID);
|
||||
mNormalBatterySipper.totalPowerMah = POWER_MAH;
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
|
||||
|
||||
mCellBatterySipper.drainType = BatterySipper.DrainType.CELL;
|
||||
mCellBatterySipper.totalPowerMah = POWER_MAH;
|
||||
|
||||
when(mBatteryLayoutPref.findViewById(R.id.summary1)).thenReturn(mSummary1);
|
||||
when(mBatteryLayoutPref.findViewById(R.id.battery_percent)).thenReturn(mBatteryPercentText);
|
||||
when(mBatteryLayoutPref.findViewById(R.id.battery_header_icon))
|
||||
.thenReturn(mBatteryMeterView);
|
||||
mFragment.setBatteryLayoutPreference(mBatteryLayoutPref);
|
||||
|
||||
mScreenBatterySipper.drainType = BatterySipper.DrainType.SCREEN;
|
||||
mScreenBatterySipper.usageTimeMs = USAGE_TIME_MS;
|
||||
|
||||
mUsageList = new ArrayList<>();
|
||||
mUsageList.add(mNormalBatterySipper);
|
||||
mUsageList.add(mScreenBatterySipper);
|
||||
mUsageList.add(mCellBatterySipper);
|
||||
|
||||
mFragment.mStatsHelper = mBatteryHelper;
|
||||
when(mBatteryHelper.getUsageList()).thenReturn(mUsageList);
|
||||
mFragment.mScreenUsagePref = mScreenUsagePref;
|
||||
mFragment.mLastFullChargePref = mLastFullChargePref;
|
||||
mFragment.mBatteryUtils = spy(new BatteryUtils(mRealContext));
|
||||
mFragment.mAppListGroup = mAppListGroup;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOptionsMenu_menuHighPower_metricEventInvoked() {
|
||||
mFragment.onOptionsItemSelected(mHighPowerMenu);
|
||||
|
||||
verify(mFeatureFactory.metricsFeatureProvider).action(mRealContext,
|
||||
MetricsProto.MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_OPTIMIZATION);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOptionsMenu_menuAppToggle_metricEventInvoked() {
|
||||
mFragment.onOptionsItemSelected(mToggleAppsMenu);
|
||||
mFragment.mShowAllApps = false;
|
||||
|
||||
verify(mFeatureFactory.metricsFeatureProvider).action(mRealContext,
|
||||
MetricsProto.MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_APPS_TOGGLE, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOptionsMenu_toggleAppsEnabled() {
|
||||
when(mFeatureFactory.powerUsageFeatureProvider.isPowerAccountingToggleEnabled())
|
||||
.thenReturn(true);
|
||||
mFragment.mShowAllApps = false;
|
||||
|
||||
mFragment.onCreateOptionsMenu(mMenu, mMenuInflater);
|
||||
|
||||
verify(mMenu).add(Menu.NONE, MENU_TOGGLE_APPS, Menu.NONE, R.string.show_all_apps);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOptionsMenu_clickToggleAppsMenu_dataChanged() {
|
||||
testToggleAllApps(true);
|
||||
testToggleAllApps(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractKeyFromSipper_typeAPPUidObjectNull_returnPackageNames() {
|
||||
mNormalBatterySipper.uidObj = null;
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
|
||||
|
||||
final String key = mFragment.extractKeyFromSipper(mNormalBatterySipper);
|
||||
assertThat(key).isEqualTo(TextUtils.concat(mNormalBatterySipper.getPackages()).toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractKeyFromSipper_typeOther_returnDrainType() {
|
||||
mNormalBatterySipper.uidObj = null;
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.BLUETOOTH;
|
||||
|
||||
final String key = mFragment.extractKeyFromSipper(mNormalBatterySipper);
|
||||
assertThat(key).isEqualTo(mNormalBatterySipper.drainType.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractKeyFromSipper_typeUser_returnDrainTypeWithUserId() {
|
||||
mNormalBatterySipper.uidObj = null;
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.USER;
|
||||
mNormalBatterySipper.userId = 2;
|
||||
|
||||
final String key = mFragment.extractKeyFromSipper(mNormalBatterySipper);
|
||||
assertThat(key).isEqualTo("USER2");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testExtractKeyFromSipper_typeAPPUidObjectNotNull_returnUid() {
|
||||
mNormalBatterySipper.uidObj = new BatteryStatsImpl.Uid(new BatteryStatsImpl(), UID);
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
|
||||
|
||||
final String key = mFragment.extractKeyFromSipper(mNormalBatterySipper);
|
||||
assertThat(key).isEqualTo(Integer.toString(mNormalBatterySipper.getUid()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetUsageSummary_timeLessThanOneMinute_DoNotSetSummary() {
|
||||
mNormalBatterySipper.usageTimeMs = 59 * DateUtils.SECOND_IN_MILLIS;
|
||||
|
||||
mFragment.setUsageSummary(mPreference, mNormalBatterySipper);
|
||||
assertThat(mPreference.getSummary()).isNull();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetUsageSummary_timeMoreThanOneMinute_normalApp_setScreenSummary() {
|
||||
mNormalBatterySipper.usageTimeMs = 2 * DateUtils.MINUTE_IN_MILLIS;
|
||||
doReturn(mRealContext.getText(R.string.battery_used_for)).when(mFragment)
|
||||
.getText(R.string.battery_used_for);
|
||||
when(mFragment.getContext()).thenReturn(mRealContext);
|
||||
|
||||
mFragment.setUsageSummary(mPreference, mNormalBatterySipper);
|
||||
|
||||
assertThat(mPreference.getSummary().toString()).isEqualTo("Used for 2m");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetUsageSummary_timeMoreThanOneMinute_hiddenApp_setUsedSummary() {
|
||||
mNormalBatterySipper.usageTimeMs = 2 * DateUtils.MINUTE_IN_MILLIS;
|
||||
doReturn(true).when(mFragment.mBatteryUtils).shouldHideSipper(mNormalBatterySipper);
|
||||
when(mFragment.getContext()).thenReturn(mRealContext);
|
||||
|
||||
mFragment.setUsageSummary(mPreference, mNormalBatterySipper);
|
||||
|
||||
assertThat(mPreference.getSummary().toString()).isEqualTo("2m");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetUsageSummary_timeMoreThanOneMinute_notApp_setUsedSummary() {
|
||||
mNormalBatterySipper.usageTimeMs = 2 * DateUtils.MINUTE_IN_MILLIS;
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.PHONE;
|
||||
when(mFragment.getContext()).thenReturn(mRealContext);
|
||||
|
||||
mFragment.setUsageSummary(mPreference, mNormalBatterySipper);
|
||||
|
||||
assertThat(mPreference.getSummary().toString()).isEqualTo("2m");
|
||||
}
|
||||
|
||||
private void testToggleAllApps(final boolean isShowApps) {
|
||||
mFragment.mShowAllApps = isShowApps;
|
||||
|
||||
mFragment.onOptionsItemSelected(mToggleAppsMenu);
|
||||
assertThat(mFragment.mShowAllApps).isEqualTo(!isShowApps);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindBatterySipperByType_findTypeScreen() {
|
||||
BatterySipper sipper =
|
||||
mFragment.findBatterySipperByType(mUsageList, BatterySipper.DrainType.SCREEN);
|
||||
|
||||
assertThat(sipper).isSameAs(mScreenBatterySipper);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindBatterySipperByType_findTypeApp() {
|
||||
BatterySipper sipper =
|
||||
mFragment.findBatterySipperByType(mUsageList, BatterySipper.DrainType.APP);
|
||||
|
||||
assertThat(sipper).isSameAs(mNormalBatterySipper);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateScreenPreference_showCorrectSummary() {
|
||||
doReturn(mScreenBatterySipper).when(mFragment).findBatterySipperByType(any(), any());
|
||||
when(mFragment.getContext()).thenReturn(mRealContext);
|
||||
final CharSequence expectedSummary =
|
||||
StringUtil.formatElapsedTime(mRealContext, USAGE_TIME_MS, false);
|
||||
|
||||
mFragment.updateScreenPreference();
|
||||
|
||||
assertThat(mScreenUsagePref.getSubtitle()).isEqualTo(expectedSummary);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateLastFullChargePreference_showCorrectSummary() {
|
||||
when(mFragment.getContext()).thenReturn(mRealContext);
|
||||
|
||||
mFragment.updateLastFullChargePreference(TIME_SINCE_LAST_FULL_CHARGE_MS);
|
||||
|
||||
assertThat(mLastFullChargePref.getSubtitle()).isEqualTo("2 hours ago");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdatePreference_usageListEmpty_shouldNotCrash() {
|
||||
when(mBatteryHelper.getUsageList()).thenReturn(new ArrayList<>());
|
||||
doReturn(STUB_STRING).when(mFragment).getString(anyInt(), any());
|
||||
when(mFragment.getContext()).thenReturn(mRealContext);
|
||||
|
||||
// Should not crash when update
|
||||
mFragment.updateScreenPreference();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculatePercentage() {
|
||||
final double percent = mFragment.calculatePercentage(POWER_MAH, DISCHARGE_AMOUNT);
|
||||
assertThat(percent).isWithin(PRECISION).of(POWER_USAGE_PERCENTAGE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPreferenceControllers_getPreferenceKeys_existInPreferenceScreen() {
|
||||
final Context context = RuntimeEnvironment.application;
|
||||
final PowerUsageSummary fragment = new PowerUsageSummary();
|
||||
final List<String> preferenceScreenKeys =
|
||||
XmlTestUtils.getKeysFromPreferenceXml(context, fragment.getPreferenceScreenResId());
|
||||
final List<String> preferenceKeys = new ArrayList<>();
|
||||
|
||||
for (AbstractPreferenceController controller : fragment.createPreferenceControllers(context)) {
|
||||
preferenceKeys.add(controller.getPreferenceKey());
|
||||
}
|
||||
|
||||
assertThat(preferenceScreenKeys).containsAllIn(preferenceKeys);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateAnomalySparseArray() {
|
||||
mFragment.mAnomalySparseArray = new SparseArray<>();
|
||||
final List<Anomaly> anomalies = new ArrayList<>();
|
||||
final Anomaly anomaly1 = new Anomaly.Builder().setUid(UID).build();
|
||||
final Anomaly anomaly2 = new Anomaly.Builder().setUid(UID).build();
|
||||
final Anomaly anomaly3 = new Anomaly.Builder().setUid(UID_2).build();
|
||||
anomalies.add(anomaly1);
|
||||
anomalies.add(anomaly2);
|
||||
anomalies.add(anomaly3);
|
||||
|
||||
mFragment.updateAnomalySparseArray(anomalies);
|
||||
|
||||
assertThat(mFragment.mAnomalySparseArray.get(UID)).containsExactly(anomaly1, anomaly2);
|
||||
assertThat(mFragment.mAnomalySparseArray.get(UID_2)).containsExactly(anomaly3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitAnomalyDetectionIfPossible_detectionEnabled_init() {
|
||||
doReturn(mLoaderManager).when(mFragment).getLoaderManager();
|
||||
doReturn(mAnomalyDetectionPolicy).when(mFragment).getAnomalyDetectionPolicy();
|
||||
when(mAnomalyDetectionPolicy.isAnomalyDetectionEnabled()).thenReturn(true);
|
||||
|
||||
mFragment.restartAnomalyDetectionIfPossible();
|
||||
|
||||
verify(mLoaderManager)
|
||||
.restartLoader(eq(PowerUsageSummaryLegacy.ANOMALY_LOADER), eq(Bundle.EMPTY), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSaveInstanceState_showAllAppsRestored() {
|
||||
Bundle bundle = new Bundle();
|
||||
mFragment.mShowAllApps = true;
|
||||
doReturn(mPreferenceScreen).when(mFragment).getPreferenceScreen();
|
||||
|
||||
mFragment.onSaveInstanceState(bundle);
|
||||
mFragment.restoreSavedInstance(bundle);
|
||||
|
||||
assertThat(mFragment.mShowAllApps).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRefreshAnomalyIcon_containsAnomaly_showAnomalyIcon() {
|
||||
PowerGaugePreference preference = new PowerGaugePreference(mRealContext);
|
||||
final String key = mFragment.extractKeyFromUid(UID);
|
||||
preference.setKey(key);
|
||||
doReturn(preference).when(mAppListGroup).findPreference(key);
|
||||
mFragment.mAnomalySparseArray = new SparseArray<>();
|
||||
mFragment.mAnomalySparseArray.append(UID, null);
|
||||
|
||||
mFragment.refreshAnomalyIcon();
|
||||
|
||||
assertThat(preference.showAnomalyIcon()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSipper_typeOvercounted_returnTrue() {
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.OVERCOUNTED;
|
||||
|
||||
assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSipper_typeUnaccounted_returnTrue() {
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.UNACCOUNTED;
|
||||
|
||||
assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShouldHideSipper_typeNormal_returnFalse() {
|
||||
mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
|
||||
|
||||
assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDebugMode() {
|
||||
doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isEstimateDebugEnabled();
|
||||
doReturn(new TextView(mRealContext)).when(mBatteryLayoutPref).findViewById(R.id.summary2);
|
||||
|
||||
mFragment.restartBatteryInfoLoader();
|
||||
ArgumentCaptor<View.OnLongClickListener> listener = ArgumentCaptor.forClass(
|
||||
View.OnLongClickListener.class);
|
||||
verify(mSummary1).setOnLongClickListener(listener.capture());
|
||||
|
||||
// Calling the listener should disable it.
|
||||
listener.getValue().onLongClick(mSummary1);
|
||||
verify(mSummary1).setOnLongClickListener(null);
|
||||
|
||||
// Restarting the loader should reset the listener.
|
||||
mFragment.restartBatteryInfoLoader();
|
||||
verify(mSummary1, times(2)).setOnLongClickListener(any(View.OnLongClickListener.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRestartBatteryStatsLoader_notClearHeader_quickUpdateNotInvoked() {
|
||||
mFragment.mBatteryHeaderPreferenceController = mBatteryHeaderPreferenceController;
|
||||
|
||||
mFragment.restartBatteryStatsLoader(false /* clearHeader */);
|
||||
|
||||
verify(mBatteryHeaderPreferenceController, never()).quickUpdateHeaderPreference();
|
||||
}
|
||||
|
||||
public static class TestFragment extends PowerUsageSummaryLegacy {
|
||||
|
||||
private Context mContext;
|
||||
|
||||
public TestFragment(Context context) {
|
||||
mContext = context;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Context getContext() {
|
||||
return mContext;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void startActivity(Intent intent) {
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void refreshUi() {
|
||||
// Leave it empty for toggle apps menu test
|
||||
}
|
||||
|
||||
@Override
|
||||
void showBothEstimates() {
|
||||
List<BatteryInfo> fakeBatteryInfo = new ArrayList<>(2);
|
||||
BatteryInfo info1 = new BatteryInfo();
|
||||
info1.batteryLevel = 10;
|
||||
info1.remainingTimeUs = 10000;
|
||||
info1.discharging = true;
|
||||
|
||||
BatteryInfo info2 = new BatteryInfo();
|
||||
info2.batteryLevel = 10;
|
||||
info2.remainingTimeUs = 10000;
|
||||
info2.discharging = true;
|
||||
|
||||
fakeBatteryInfo.add(info1);
|
||||
fakeBatteryInfo.add(info2);
|
||||
updateViews(fakeBatteryInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user