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

Transition BatteryAppListPreferences to BatteryUsageStats API

Browse Source 
Bug: 173745486
Test: make RunSettingsRoboTests
Test: male RunSettingsGoogleRoboTests

Change-Id: I7af8cbcd27433b89cb2184750c6854aa74761d0d
This commit is contained in:
Dmitri Plotnikov
2021-03-08 20:11:54 -08:00
parent dba51aa233
commit 036dc189b6
13 changed files with 574 additions and 675 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java
View File

@@ -18,6 +18,7 @@ package com.android.settings.fuelgauge;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -27,21 +28,20 @@ import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.BatteryConsumer;
import android.os.BatteryStats;
import android.os.Handler;
import android.os.Process;
import android.os.SystemBatteryConsumer;
import android.os.UidBatteryConsumer;
import android.os.UserBatteryConsumer;
import android.os.UserManager;
import com.android.internal.os.BatterySipper;
import com.android.internal.os.BatterySipper.DrainType;
import com.android.settings.R;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
@@ -56,188 +56,153 @@ public class BatteryEntryTest {
private static final int APP_UID = 123;
private static final int SYSTEM_UID = Process.SYSTEM_UID;
private static final String APP_DEFAULT_PACKAGE_NAME = "com.android.test";
private static final String APP_LABEL = "Test App Name";
private static final String LABEL_PREFIX = "Label for ";
private static final String HIGH_DRAIN_PACKAGE = "com.android.test.screen";
private static final String ANDROID_PACKAGE = "android";
private static final String[] SYSTEM_PACKAGES = {HIGH_DRAIN_PACKAGE, ANDROID_PACKAGE};
@Rule public MockitoRule mocks = MockitoJUnit.rule();
@Mock private Context mockContext;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mMockContext;
@Mock private Handler mockHandler;
@Mock private PackageManager mockPackageManager;
@Mock private UserManager mockUserManager;
@Mock private UidBatteryConsumer mUidBatteryConsumer;
@Mock private SystemBatteryConsumer mSystemBatteryConsumer;
@Mock BatteryUtils mBatteryUtils;
@Before
public void stubContextToReturnMockPackageManager() {
when(mockContext.getPackageManager()).thenReturn(mockPackageManager);
when(mMockContext.getPackageManager()).thenReturn(mockPackageManager);
}
@Before
public void stubPackageManagerToReturnAppPackageAndName() throws NameNotFoundException {
when(mockPackageManager.getPackagesForUid(APP_UID))
.thenReturn(new String[] {APP_DEFAULT_PACKAGE_NAME});
ApplicationInfo appInfo = mock(ApplicationInfo.class);
when(mockPackageManager.getApplicationInfo(APP_DEFAULT_PACKAGE_NAME, 0 /* no flags */))
.thenReturn(appInfo);
when(mockPackageManager.getApplicationLabel(appInfo)).thenReturn(APP_LABEL);
when(mockPackageManager.getApplicationInfo(anyString(), eq(0) /* no flags */))
.thenAnswer(invocation -> {
ApplicationInfo info = new ApplicationInfo();
info.packageName = invocation.getArgument(0);
return info;
});
when(mockPackageManager.getApplicationLabel(any(ApplicationInfo.class)))
.thenAnswer(invocation -> LABEL_PREFIX
+ ((ApplicationInfo) invocation.getArgument(0)).packageName);
}
private BatteryEntry createBatteryEntryForApp() {
return new BatteryEntry(mockContext, mockHandler, mockUserManager, createSipperForApp(),
null, null);
private BatteryEntry createBatteryEntryForApp(String[] packages, String packageName,
String highDrainPackage) {
UidBatteryConsumer consumer = mock(UidBatteryConsumer.class);
when(consumer.getUid()).thenReturn(APP_UID);
when(consumer.getPackageWithHighestDrain()).thenReturn(highDrainPackage);
return new BatteryEntry(mMockContext, mockHandler, mockUserManager,
consumer, false, packages, packageName);
}
private BatterySipper createSipperForApp() {
BatterySipper sipper =
new BatterySipper(DrainType.APP, new FakeUid(APP_UID), 0 /* power use */);
sipper.packageWithHighestDrain = HIGH_DRAIN_PACKAGE;
return sipper;
private BatteryEntry createSystemBatteryEntry(int drainType) {
SystemBatteryConsumer consumer = mock(SystemBatteryConsumer.class);
when(consumer.getDrainType()).thenReturn(drainType);
return new BatteryEntry(mMockContext, mockHandler, mockUserManager,
consumer, false, null, null);
}
private BatterySipper createSipperForSystem() {
BatterySipper sipper =
new BatterySipper(DrainType.APP, new FakeUid(SYSTEM_UID), 0 /* power use */);
sipper.packageWithHighestDrain = HIGH_DRAIN_PACKAGE;
sipper.mPackages = SYSTEM_PACKAGES;
return sipper;
}
private BatterySipper createNonAppSipper() {
return new BatterySipper(DrainType.IDLE, null, 0 /* power use */);
private BatteryEntry createUserBatteryConsumer(int userId) {
UserBatteryConsumer consumer = mock(UserBatteryConsumer.class);
when(consumer.getUserId()).thenReturn(userId);
return new BatteryEntry(mMockContext, mockHandler, mockUserManager,
consumer, false, null, null);
}
@Test
public void batteryEntryForApp_shouldSetDefaultPackageNameAndLabel() throws Exception {
BatteryEntry entry = createBatteryEntryForApp();
BatteryEntry entry = createBatteryEntryForApp(null, APP_DEFAULT_PACKAGE_NAME,
HIGH_DRAIN_PACKAGE);
assertThat(entry.getDefaultPackageName()).isEqualTo(APP_DEFAULT_PACKAGE_NAME);
assertThat(entry.getLabel()).isEqualTo(APP_LABEL);
assertThat(entry.getLabel()).isEqualTo(LABEL_PREFIX + APP_DEFAULT_PACKAGE_NAME);
}
@Test
public void batteryEntryForApp_shouldSetLabelAsPackageName_whenPackageCannotBeFound()
throws Exception {
when(mockPackageManager.getApplicationInfo(APP_DEFAULT_PACKAGE_NAME, 0 /* no flags */))
.thenThrow(new NameNotFoundException());
throws Exception {
when(mockPackageManager.getApplicationInfo(APP_DEFAULT_PACKAGE_NAME, 0 /* no flags */))
.thenThrow(new NameNotFoundException());
BatteryEntry entry = createBatteryEntryForApp();
BatteryEntry entry = createBatteryEntryForApp(null, APP_DEFAULT_PACKAGE_NAME, null);
assertThat(entry.getLabel()).isEqualTo(APP_DEFAULT_PACKAGE_NAME);
assertThat(entry.getLabel()).isEqualTo(APP_DEFAULT_PACKAGE_NAME);
}
@Test
public void batteryEntryForApp_shouldSetHighestDrainPackage_whenPackagesCannotBeFoundForUid() {
when(mockPackageManager.getPackagesForUid(APP_UID)).thenReturn(null);
BatteryEntry entry = createBatteryEntryForApp();
BatteryEntry entry = createBatteryEntryForApp(null, null, HIGH_DRAIN_PACKAGE);
assertThat(entry.getLabel()).isEqualTo(HIGH_DRAIN_PACKAGE);
assertThat(entry.getLabel()).isEqualTo(LABEL_PREFIX + HIGH_DRAIN_PACKAGE);
}
@Test
public void batteryEntryForApp_shouldSetHighestDrainPackage_whenMultiplePackagesFoundForUid() {
when(mockPackageManager.getPackagesForUid(APP_UID))
.thenReturn(new String[] {APP_DEFAULT_PACKAGE_NAME, "package2", "package3"});
BatteryEntry entry = createBatteryEntryForApp(
new String[] {APP_DEFAULT_PACKAGE_NAME, "package2", "package3"}, null,
HIGH_DRAIN_PACKAGE);
BatteryEntry entry = createBatteryEntryForApp();
assertThat(entry.getLabel()).isEqualTo(HIGH_DRAIN_PACKAGE);
assertThat(entry.getLabel()).isEqualTo(LABEL_PREFIX + HIGH_DRAIN_PACKAGE);
}
@Test
public void batteryEntryForAOD_containCorrectInfo() {
final BatterySipper batterySipper = mock(BatterySipper.class);
batterySipper.drainType = DrainType.AMBIENT_DISPLAY;
final SystemBatteryConsumer systemBatteryConsumer = mock(SystemBatteryConsumer.class);
when(systemBatteryConsumer.getDrainType())
.thenReturn(SystemBatteryConsumer.DRAIN_TYPE_AMBIENT_DISPLAY);
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, batterySipper, null, null);
mockUserManager, systemBatteryConsumer, false, null, null);
assertThat(entry.iconId).isEqualTo(R.drawable.ic_settings_aod);
assertThat(entry.name).isEqualTo("Ambient display");
}
@Test
public void extractPackageFromSipper_systemSipper_returnSystemPackage() {
assertThat(BatteryEntry.extractPackagesFromSipper(createSipperForSystem()))
.isEqualTo(new String[] {ANDROID_PACKAGE});
}
@Test
public void extractPackageFromSipper_normalSipper_returnDefaultPackage() {
BatterySipper sipper = createSipperForApp();
assertThat(BatteryEntry.extractPackagesFromSipper(sipper)).isEqualTo(sipper.mPackages);
}
@Test
public void getTimeInForegroundMs_app() {
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, null, mUidBatteryConsumer, null);
mockUserManager, mUidBatteryConsumer, false, null, null);
when(mUidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND))
.thenReturn(100L);
assertThat(entry.getTimeInForegroundMs(mBatteryUtils)).isEqualTo(100L);
assertThat(entry.getTimeInForegroundMs()).isEqualTo(100L);
}
@Test
public void getTimeInForegroundMs_systemConsumer() {
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, createNonAppSipper(), mSystemBatteryConsumer, null);
mockUserManager, mSystemBatteryConsumer, false, null, null);
when(mSystemBatteryConsumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE))
.thenReturn(100L);
assertThat(entry.getTimeInForegroundMs(mBatteryUtils)).isEqualTo(100L);
}
@Test
public void getTimeInForegroundMs_useSipper() {
final BatterySipper batterySipper = createSipperForApp();
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, batterySipper, null, null);
when(mBatteryUtils.getProcessTimeMs(eq(BatteryUtils.StatusType.FOREGROUND),
any(BatteryStats.Uid.class), eq(BatteryStats.STATS_SINCE_CHARGED)))
.thenReturn(100L);
assertThat(entry.getTimeInForegroundMs(mBatteryUtils)).isEqualTo(100L);
assertThat(entry.getTimeInForegroundMs()).isEqualTo(100L);
}
@Test
public void getTimeInBackgroundMs_app() {
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, null, mUidBatteryConsumer, null);
mockUserManager, mUidBatteryConsumer, false, null, null);
when(mUidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND))
.thenReturn(100L);
assertThat(entry.getTimeInBackgroundMs(mBatteryUtils)).isEqualTo(100L);
assertThat(entry.getTimeInBackgroundMs()).isEqualTo(100L);
}
@Test
public void getTimeInBackgroundMs_systemConsumer() {
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, createNonAppSipper(), mSystemBatteryConsumer, null);
mockUserManager, mSystemBatteryConsumer, false, null, null);
when(mSystemBatteryConsumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE))
.thenReturn(100L);
assertThat(entry.getTimeInBackgroundMs(mBatteryUtils)).isEqualTo(0);
}
@Test
public void getTimeInBackgroundMs_useSipper() {
final BatterySipper batterySipper = createSipperForApp();
final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
mockUserManager, batterySipper, null, null);
when(mBatteryUtils.getProcessTimeMs(eq(BatteryUtils.StatusType.BACKGROUND),
any(BatteryStats.Uid.class), eq(BatteryStats.STATS_SINCE_CHARGED)))
.thenReturn(100L);
assertThat(entry.getTimeInBackgroundMs(mBatteryUtils)).isEqualTo(100L);
assertThat(entry.getTimeInBackgroundMs()).isEqualTo(0);
}
@Test
@@ -249,7 +214,29 @@ public class BatteryEntryTest {
assertThat(BatteryEntry.sUidCache).isNotEmpty();
Locale.setDefault(new Locale("zh_TW"));
createBatteryEntryForApp();
createBatteryEntryForApp(null, null, HIGH_DRAIN_PACKAGE);
assertThat(BatteryEntry.sUidCache).isEmpty(); // check if cache is clear
}
@Test
public void getKey_UidBatteryConsumer() {
final BatteryEntry entry = createBatteryEntryForApp(null, null, null);
final String key = entry.getKey();
assertThat(key).isEqualTo("123");
}
@Test
public void getKey_SystemBatteryConsumer_returnDrainType() {
final BatteryEntry entry =
createSystemBatteryEntry(SystemBatteryConsumer.DRAIN_TYPE_BLUETOOTH);
final String key = entry.getKey();
assertThat(key).isEqualTo("S|2");
}
@Test
public void getKey_UserBatteryConsumer_returnUserId() {
final BatteryEntry entry = createUserBatteryConsumer(2);
final String key = entry.getKey();
assertThat(key).isEqualTo("U|2");
}
}