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

Battery usage page latency improvement (1-8)

Browse Source 
Save battery slot diff data into database in hourly job. Then read the
saved diff data and only calculate the remaining data. This could speed
up the battery usage loading.

Bug: 261163071
Fix: 261163071
Test: manual
Change-Id: Icd4868ca9326b64b17ddbccdb0311e755dc68026
This commit is contained in:
Zaiyue Xue
2023-07-14 20:57:49 +08:00
parent 83c8f47ddd
commit 50da7feeb9
49 changed files with 2713 additions and 1443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/AppUsageDataLoaderTest.java
View File

@@ -1,102 +0,0 @@
/*
* Copyright (C) 2022 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.batteryusage;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.os.UserManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
public final class AppUsageDataLoaderTest {
private Context mContext;
@Mock
private ContentResolver mMockContentResolver;
@Mock
private UserManager mUserManager;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
doReturn(mContext).when(mContext).getApplicationContext();
doReturn(mMockContentResolver).when(mContext).getContentResolver();
doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
doReturn(new Intent()).when(mContext).registerReceiver(any(), any());
}
@Test
public void loadAppUsageData_withData_insertFakeDataIntoProvider() {
final List<AppUsageEvent> AppUsageEventList = new ArrayList<>();
final AppUsageEvent appUsageEvent = AppUsageEvent.newBuilder().setUid(0).build();
AppUsageEventList.add(appUsageEvent);
AppUsageDataLoader.sFakeAppUsageEventsSupplier = () -> new HashMap<>();
AppUsageDataLoader.sFakeUsageEventsListSupplier = () -> AppUsageEventList;
AppUsageDataLoader.loadAppUsageData(mContext);
verify(mMockContentResolver).bulkInsert(any(), any());
verify(mMockContentResolver).notifyChange(any(), any());
}
@Test
public void loadAppUsageData_nullAppUsageEvents_notInsertDataIntoProvider() {
AppUsageDataLoader.sFakeAppUsageEventsSupplier = () -> null;
AppUsageDataLoader.loadAppUsageData(mContext);
verifyNoMoreInteractions(mMockContentResolver);
}
@Test
public void loadAppUsageData_nullUsageEventsList_notInsertDataIntoProvider() {
AppUsageDataLoader.sFakeAppUsageEventsSupplier = () -> new HashMap<>();
AppUsageDataLoader.sFakeUsageEventsListSupplier = () -> null;
AppUsageDataLoader.loadAppUsageData(mContext);
verifyNoMoreInteractions(mMockContentResolver);
}
@Test
public void loadAppUsageData_emptyUsageEventsList_notInsertDataIntoProvider() {
AppUsageDataLoader.sFakeAppUsageEventsSupplier = () -> new HashMap<>();
AppUsageDataLoader.sFakeUsageEventsListSupplier = () -> new ArrayList<>();
AppUsageDataLoader.loadAppUsageData(mContext);
verifyNoMoreInteractions(mMockContentResolver);
}
}

100
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java
View File

@@ -16,6 +16,8 @@
package com.android.settings.fuelgauge.batteryusage;
import static com.android.settings.fuelgauge.batteryusage.BatteryChartViewModel.SELECTED_INDEX_ALL;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.anyFloat;
@@ -30,7 +32,6 @@ import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
@@ -39,6 +40,7 @@ import android.os.Bundle;
import android.os.LocaleList;
import android.os.UserManager;
import android.text.format.DateUtils;
import android.util.ArrayMap;
import android.view.View;
import android.view.ViewPropertyAnimator;
import android.widget.LinearLayout;
@@ -54,7 +56,6 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
@@ -112,6 +113,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.mPrefContext = mContext;
mBatteryChartPreferenceController.mDailyChartView = mDailyChartView;
mBatteryChartPreferenceController.mHourlyChartView = mHourlyChartView;
BatteryDiffEntry.clearCache();
// Adds fake testing data.
BatteryDiffEntry.sResourceCache.put(
"fakeBatteryDiffEntryKey",
@@ -144,7 +146,7 @@ public final class BatteryChartPreferenceControllerTest {
reset(mHourlyChartView);
setupHourlyChartViewAnimationMock();
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(6));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(6));
verify(mDailyChartView, atLeastOnce()).setVisibility(View.GONE);
// Ignore fast refresh ui from the data processor callback.
@@ -176,16 +178,18 @@ public final class BatteryChartPreferenceControllerTest {
BatteryChartViewModel.AxisLabelPosition.CENTER_OF_TRAPEZOIDS,
mBatteryChartPreferenceController.mDailyChartLabelTextGenerator);
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(60));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(60));
mBatteryChartPreferenceController.onBatteryUsageMapUpdate(getEmptyBatteryUsageMap());
verify(mDailyChartView, atLeastOnce()).setVisibility(View.VISIBLE);
verify(mViewPropertyAnimator, atLeastOnce()).alpha(0f);
verify(mDailyChartView).setViewModel(expectedDailyViewModel);
verify(mDailyChartView, atLeastOnce()).setViewModel(expectedDailyViewModel);
reset(mDailyChartView);
reset(mHourlyChartView);
setupHourlyChartViewAnimationMock();
doReturn(mLayoutParams).when(mDailyChartView).getLayoutParams();
doReturn(View.GONE).when(mHourlyChartView).getVisibility();
mBatteryChartPreferenceController.mDailyChartIndex = 0;
mBatteryChartPreferenceController.refreshUi();
verify(mDailyChartView).setVisibility(View.VISIBLE);
@@ -245,8 +249,7 @@ public final class BatteryChartPreferenceControllerTest {
setupHourlyChartViewAnimationMock();
doReturn(mLayoutParams).when(mDailyChartView).getLayoutParams();
mBatteryChartPreferenceController.mDailyChartIndex = 2;
mBatteryChartPreferenceController.mHourlyChartIndex =
BatteryChartViewModel.SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.mHourlyChartIndex = SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.refreshUi();
verify(mDailyChartView).setVisibility(View.VISIBLE);
verify(mViewPropertyAnimator, atLeastOnce()).alpha(1f);
@@ -272,13 +275,15 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void refreshUi_normalCase_returnTrue() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(6));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(6));
mBatteryChartPreferenceController.onBatteryUsageMapUpdate(getEmptyBatteryUsageMap());
assertThat(mBatteryChartPreferenceController.refreshUi()).isTrue();
}
@Test
public void refreshUi_batteryIndexedMapIsNull_returnTrue() {
mBatteryChartPreferenceController.setBatteryHistoryMap(null);
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(null);
mBatteryChartPreferenceController.onBatteryUsageMapUpdate(getEmptyBatteryUsageMap());
assertThat(mBatteryChartPreferenceController.refreshUi()).isTrue();
}
@@ -296,38 +301,34 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void selectedSlotText_selectAllDaysAllHours_returnNull() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(60));
mBatteryChartPreferenceController.mDailyChartIndex =
BatteryChartViewModel.SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.mHourlyChartIndex =
BatteryChartViewModel.SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(60));
mBatteryChartPreferenceController.mDailyChartIndex = SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.mHourlyChartIndex = SELECTED_INDEX_ALL;
assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(null);
}
@Test
public void selectedSlotText_onlyOneDayDataSelectAllHours_returnNull() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(6));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(6));
mBatteryChartPreferenceController.mDailyChartIndex = 0;
mBatteryChartPreferenceController.mHourlyChartIndex =
BatteryChartViewModel.SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.mHourlyChartIndex = SELECTED_INDEX_ALL;
assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo(null);
}
@Test
public void selectedSlotText_selectADayAllHours_onlyDayText() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(60));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(60));
mBatteryChartPreferenceController.mDailyChartIndex = 1;
mBatteryChartPreferenceController.mHourlyChartIndex =
BatteryChartViewModel.SELECTED_INDEX_ALL;
mBatteryChartPreferenceController.mHourlyChartIndex = SELECTED_INDEX_ALL;
assertThat(mBatteryChartPreferenceController.getSlotInformation()).isEqualTo("Sunday");
}
@Test
public void selectedSlotText_onlyOneDayDataSelectAnHour_onlyHourText() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(6));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(6));
mBatteryChartPreferenceController.mDailyChartIndex = 0;
mBatteryChartPreferenceController.mHourlyChartIndex = 2;
@@ -337,7 +338,7 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void selectedSlotText_SelectADayAnHour_dayAndHourText() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(60));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(60));
mBatteryChartPreferenceController.mDailyChartIndex = 1;
mBatteryChartPreferenceController.mHourlyChartIndex = 8;
@@ -347,7 +348,7 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void selectedSlotText_selectFirstSlot_withMinuteText() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(6));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(6));
mBatteryChartPreferenceController.mDailyChartIndex = 0;
mBatteryChartPreferenceController.mHourlyChartIndex = 0;
@@ -357,7 +358,7 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void selectedSlotText_selectLastSlot_withNowText() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(6));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(6));
mBatteryChartPreferenceController.mDailyChartIndex = 0;
mBatteryChartPreferenceController.mHourlyChartIndex = 3;
@@ -367,7 +368,7 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void selectedSlotText_selectOnlySlot_withMinuteAndNowText() {
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(1));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(1));
mBatteryChartPreferenceController.mDailyChartIndex = 0;
mBatteryChartPreferenceController.mHourlyChartIndex = 0;
@@ -388,7 +389,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.mHourlyChartIndex = -1;
mBatteryChartPreferenceController.onCreate(bundle);
mBatteryChartPreferenceController.setBatteryHistoryMap(createBatteryHistoryMap(25));
mBatteryChartPreferenceController.onBatteryLevelDataUpdate(createBatteryLevelData(25));
assertThat(mBatteryChartPreferenceController.mDailyChartIndex)
.isEqualTo(expectedDailyIndex);
@@ -398,9 +399,7 @@ public final class BatteryChartPreferenceControllerTest {
@Test
public void getTotalHours_getExpectedResult() {
Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = createBatteryHistoryMap(60);
BatteryLevelData batteryLevelData =
DataProcessManager.getBatteryLevelData(mContext, null, batteryHistoryMap, null);
BatteryLevelData batteryLevelData = createBatteryLevelData(60);
final int totalHour = BatteryChartPreferenceController.getTotalHours(batteryLevelData);
@@ -413,37 +412,26 @@ public final class BatteryChartPreferenceControllerTest {
return 1619247600000L + index * DateUtils.HOUR_IN_MILLIS;
}
private static Map<Long, Map<String, BatteryHistEntry>> createBatteryHistoryMap(
int numOfHours) {
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = new HashMap<>();
for (int index = 0; index < numOfHours; index++) {
final ContentValues values = new ContentValues();
final DeviceBatteryState deviceBatteryState =
DeviceBatteryState
.newBuilder()
.setBatteryLevel(100 - index)
.build();
final BatteryInformation batteryInformation =
BatteryInformation
.newBuilder()
.setDeviceBatteryState(deviceBatteryState)
.setConsumePower(100 - index)
.build();
values.put(BatteryHistEntry.KEY_BATTERY_INFORMATION,
ConvertUtils.convertBatteryInformationToString(batteryInformation));
values.put(BatteryHistEntry.KEY_PACKAGE_NAME, "package" + index);
final BatteryHistEntry entry = new BatteryHistEntry(values);
final Map<String, BatteryHistEntry> entryMap = new HashMap<>();
entryMap.put("fake_entry_key" + index, entry);
long timestamp = generateTimestamp(index);
private static BatteryLevelData createBatteryLevelData(int numOfHours) {
Map<Long, Integer> batteryLevelMap = new ArrayMap<>();
for (int index = 0; index < numOfHours; index += 2) {
final Integer level = 100 - index;
Long timestamp = generateTimestamp(index);
if (index == 0) {
timestamp += DateUtils.MINUTE_IN_MILLIS;
index--;
}
batteryHistoryMap.put(timestamp, entryMap);
batteryLevelMap.put(timestamp, level);
}
DataProcessor.sTestCurrentTimeMillis =
generateTimestamp(numOfHours - 1) + DateUtils.MINUTE_IN_MILLIS * 2;
return batteryHistoryMap;
long current = generateTimestamp(numOfHours - 1) + DateUtils.MINUTE_IN_MILLIS * 2;
batteryLevelMap.put(current, 66);
DataProcessor.sTestCurrentTimeMillis = current;
return new BatteryLevelData(batteryLevelMap);
}
private static Map<Integer, Map<Integer, BatteryDiffData>> getEmptyBatteryUsageMap() {
return Map.of(SELECTED_INDEX_ALL, Map.of(SELECTED_INDEX_ALL, new BatteryDiffData(
null, 0, 0, 0, 0, 0, List.of(), List.of(), Set.of(), Set.of(), false)));
}
private BatteryChartPreferenceController createController() {

11
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffDataTest.java
View File

@@ -147,6 +147,14 @@ public class BatteryDiffDataTest {
/*foregroundUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L, isHidden);
return new BatteryDiffEntry(
context,
batteryHistEntry.mUid,
batteryHistEntry.mUserId,
batteryHistEntry.getKey(),
batteryHistEntry.mIsHidden,
batteryHistEntry.mDrainType,
batteryHistEntry.mPackageName,
batteryHistEntry.mAppLabel,
batteryHistEntry.mConsumerType,
/*foregroundUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0,
/*screenOnTimeInMs=*/ 0,
@@ -154,8 +162,7 @@ public class BatteryDiffDataTest {
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0,
batteryHistEntry);
/*cachedUsageConsumePower=*/ 0);
}
private static BatteryHistEntry createBatteryHistEntry(

72
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java
View File

@@ -95,6 +95,14 @@ public final class BatteryDiffEntryTest {
final BatteryDiffEntry entry =
new BatteryDiffEntry(
mContext,
/*uid=*/ 0,
/*userId=*/ 0,
/*key=*/ "key",
/*isHidden=*/ false,
/*componentId=*/ -1,
/*legacyPackageName=*/ null,
/*legacyLabel=*/ null,
/*consumerType*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*foregroundUsageTimeInMs=*/ 10001L,
/*backgroundUsageTimeInMs=*/ 20002L,
/*screenOnTimeInMs=*/ 30003L,
@@ -102,8 +110,7 @@ public final class BatteryDiffEntryTest {
/*foregroundUsageConsumePower=*/ 10.0,
/*foregroundServiceUsageConsumePower=*/ 10.0,
/*backgroundUsageConsumePower=*/ 1.0,
/*cachedUsageConsumePower=*/ 1.0,
/*batteryHistEntry=*/ null);
/*cachedUsageConsumePower=*/ 1.0);
entry.setTotalConsumePower(100.0);
assertThat(entry.getPercentage()).isEqualTo(22.0);
@@ -114,6 +121,14 @@ public final class BatteryDiffEntryTest {
final BatteryDiffEntry entry =
new BatteryDiffEntry(
mContext,
/*uid=*/ 0,
/*userId=*/ 0,
/*key=*/ "key",
/*isHidden=*/ false,
/*componentId=*/ -1,
/*legacyPackageName=*/ null,
/*legacyLabel=*/ null,
/*consumerType*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*foregroundUsageTimeInMs=*/ 10001L,
/*backgroundUsageTimeInMs=*/ 20002L,
/*screenOnTimeInMs=*/ 30003L,
@@ -121,8 +136,7 @@ public final class BatteryDiffEntryTest {
/*foregroundUsageConsumePower=*/ 10.0,
/*foregroundServiceUsageConsumePower=*/ 10.0,
/*backgroundUsageConsumePower=*/ 1.0,
/*cachedUsageConsumePower=*/ 1.0,
/*batteryHistEntry=*/ null);
/*cachedUsageConsumePower=*/ 1.0);
entry.setTotalConsumePower(0);
assertThat(entry.getPercentage()).isEqualTo(0);
@@ -133,7 +147,24 @@ public final class BatteryDiffEntryTest {
final List<BatteryDiffEntry> entryList = new ArrayList<>();
// Generates fake testing data.
BatteryDiffEntry systemAppsBatteryDiffEntry =
new BatteryDiffEntry.SystemAppsBatteryDiffEntry(mContext);
new BatteryDiffEntry(
mContext,
/*uid=*/ 0,
/*userId=*/ 0,
/*key=*/ BatteryDiffEntry.SYSTEM_APPS_KEY,
/*isHidden=*/ false,
/*componentId=*/ -1,
/*legacyPackageName=*/ null,
/*legacyLabel=*/ BatteryDiffEntry.SYSTEM_APPS_KEY,
/*consumerType*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*foregroundUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0,
/*screenOnTimeInMs=*/ 0,
/*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0);
systemAppsBatteryDiffEntry.mConsumePower = 16;
systemAppsBatteryDiffEntry.setTotalConsumePower(100);
entryList.add(systemAppsBatteryDiffEntry);
@@ -448,17 +479,16 @@ public final class BatteryDiffEntryTest {
private BatteryDiffEntry createBatteryDiffEntry(
int consumerType, long uid, boolean isHidden) {
final ContentValues values = getContentValuesWithType(consumerType);
final BatteryInformation batteryInformation =
BatteryInformation
.newBuilder()
.setIsHidden(isHidden)
.build();
values.put(BatteryHistEntry.KEY_BATTERY_INFORMATION,
ConvertUtils.convertBatteryInformationToString(batteryInformation));
values.put(BatteryHistEntry.KEY_UID, uid);
return new BatteryDiffEntry(
mContext,
/*uid=*/ uid,
/*userId=*/ 0,
/*key=*/ "key",
/*isHidden=*/ isHidden,
/*componentId=*/ -1,
/*legacyPackageName=*/ null,
/*legacyLabel=*/ null,
/*consumerType*/ consumerType,
/*foregroundUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0,
/*screenOnTimeInMs=*/ 0,
@@ -466,14 +496,21 @@ public final class BatteryDiffEntryTest {
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0,
new BatteryHistEntry(values));
/*cachedUsageConsumePower=*/ 0);
}
private BatteryDiffEntry createBatteryDiffEntry(
double consumePower, BatteryHistEntry batteryHistEntry) {
final BatteryDiffEntry entry = new BatteryDiffEntry(
mContext,
batteryHistEntry.mUid,
batteryHistEntry.mUserId,
batteryHistEntry.getKey(),
batteryHistEntry.mIsHidden,
batteryHistEntry.mDrainType,
batteryHistEntry.mPackageName,
batteryHistEntry.mAppLabel,
batteryHistEntry.mConsumerType,
/*foregroundUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0,
/*screenOnTimeInMs=*/ 0,
@@ -481,8 +518,7 @@ public final class BatteryDiffEntryTest {
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0,
batteryHistEntry);
/*cachedUsageConsumePower=*/ 0);
entry.setTotalConsumePower(100.0);
return entry;
}

40
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java
View File

@@ -15,6 +15,10 @@
*/
package com.android.settings.fuelgauge.batteryusage;
import static com.android.settings.fuelgauge.batteryusage.ConvertUtils.isSystemConsumer;
import static com.android.settings.fuelgauge.batteryusage.ConvertUtils.isUidConsumer;
import static com.android.settings.fuelgauge.batteryusage.ConvertUtils.isUserConsumer;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
@@ -147,32 +151,32 @@ public final class BatteryHistEntryTest {
@Test
public void testIsAppEntry_returnExpectedResult() {
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).isAppEntry())
.isFalse();
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).isAppEntry())
.isFalse();
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).isAppEntry())
.isTrue();
assertThat(isUidConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).mConsumerType)).isFalse();
assertThat(isUidConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType)).isFalse();
assertThat(isUidConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType)).isTrue();
}
@Test
public void testIsUserEntry_returnExpectedResult() {
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).isUserEntry())
.isFalse();
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).isUserEntry())
.isTrue();
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).isUserEntry())
.isFalse();
assertThat(isUserConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).mConsumerType)).isFalse();
assertThat(isUserConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType)).isTrue();
assertThat(isUserConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType)).isFalse();
}
@Test
public void testIsSystemEntry_returnExpectedResult() {
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).isSystemEntry())
.isTrue();
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).isSystemEntry())
.isFalse();
assertThat(createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).isSystemEntry())
.isFalse();
assertThat(isSystemConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY).mConsumerType)).isTrue();
assertThat(isSystemConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_USER_BATTERY).mConsumerType)).isFalse();
assertThat(isSystemConsumer(
createEntry(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).mConsumerType)).isFalse();
}
@Test

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

@@ -27,7 +27,6 @@ import android.widget.TextView;
import androidx.preference.PreferenceViewHolder;
import com.android.settings.R;
import com.android.settings.fuelgauge.BatteryInfo;
import org.junit.Before;
import org.junit.Test;
@@ -42,8 +41,6 @@ public class BatteryHistoryPreferenceTest {
@Mock
private PreferenceViewHolder mViewHolder;
@Mock
private BatteryInfo mBatteryInfo;
@Mock
private TextView mTextView;
@Mock
private BatteryChartView mDailyChartView;
@@ -59,7 +56,6 @@ public class BatteryHistoryPreferenceTest {
LayoutInflater.from(context).inflate(R.layout.battery_chart_graph, null);
mBatteryHistoryPreference = new BatteryHistoryPreference(context, null);
mBatteryHistoryPreference.mBatteryInfo = mBatteryInfo;
mViewHolder = spy(PreferenceViewHolder.createInstanceForTests(itemView));
when(mViewHolder.findViewById(R.id.daily_battery_chart)).thenReturn(mDailyChartView);
when(mViewHolder.findViewById(R.id.hourly_battery_chart)).thenReturn(mHourlyChartView);

214
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryLevelDataTest.java Normal file
View File

@@ -0,0 +1,214 @@
/*
* Copyright (C) 2023 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.batteryusage;
import static com.google.common.truth.Truth.assertThat;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
@RunWith(RobolectricTestRunner.class)
public class BatteryLevelDataTest {
@Before
public void setUp() {
TimeZone.setDefault(TimeZone.getTimeZone("GMT+8"));
}
@Test
public void getDailyTimestamps_allDataInOneHour_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640970006000L, // 2022-01-01 01:00:06
1640973608000L // 2022-01-01 01:00:08
);
final List<Long> expectedTimestamps = List.of(
1640970006000L, // 2022-01-01 01:00:06
1640973608000L // 2022-01-01 01:00:08
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_OneHourDataPerDay_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
1641056400000L // 2022-01-02 01:00:00
);
final List<Long> expectedTimestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
1641056400000L // 2022-01-02 01:00:00
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_OneDayData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640966400000L, // 2022-01-01 00:00:00
1640970000000L, // 2022-01-01 01:00:00
1640973600000L, // 2022-01-01 02:00:00
1640977200000L, // 2022-01-01 03:00:00
1640980800000L // 2022-01-01 04:00:00
);
final List<Long> expectedTimestamps = List.of(
1640966400000L, // 2022-01-01 00:00:00
1640980800000L // 2022-01-01 04:00:00
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_MultipleDaysData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1641045600000L, // 2022-01-01 22:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641232800000L // 2022-01-04 02:00:00
);
final List<Long> expectedTimestamps = List.of(
1641045600000L, // 2022-01-01 22:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L, // 2022-01-04 00:00:00
1641232800000L // 2022-01-04 02:00:00
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_FirstDayOneHourData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641254400000L // 2022-01-04 08:00:00
);
final List<Long> expectedTimestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L, // 2022-01-04 00:00:00
1641254400000L // 2022-01-04 08:00:00
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_LastDayNoData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641225600000L // 2022-01-04 00:00:00
);
final List<Long> expectedTimestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L // 2022-01-04 00:00:00
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_LastDayOneHourData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641229200000L // 2022-01-04 01:00:00
);
final List<Long> expectedTimestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L, // 2022-01-04 00:00:00
1641229200000L // 2022-01-04 01:00:00
);
assertThat(BatteryLevelData.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void combine_normalFlow_returnExpectedResult() {
final BatteryLevelData batteryLevelData =
new BatteryLevelData(Map.of(1691596800000L, 90, 1691604000000L, 80));
final List<BatteryEvent> batteryLevelRecordEvents = List.of(
BatteryEvent.newBuilder().setTimestamp(1691586000166L).setBatteryLevel(100)
.setType(BatteryEventType.FULL_CHARGED).build(),
BatteryEvent.newBuilder().setTimestamp(1691589600000L).setBatteryLevel(98)
.setType(BatteryEventType.EVEN_HOUR).build());
BatteryLevelData result =
BatteryLevelData.combine(batteryLevelData, batteryLevelRecordEvents);
assertThat(result.getDailyBatteryLevels().getTimestamps())
.isEqualTo(List.of(1691586000166L, 1691596800000L, 1691604000000L));
assertThat(result.getDailyBatteryLevels().getLevels())
.isEqualTo(List.of(100, 90, 80));
assertThat(result.getHourlyBatteryLevelsPerDay())
.hasSize(2);
assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getTimestamps())
.isEqualTo(List.of(1691586000166L, 1691589600000L, 1691596800000L));
assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getLevels())
.isEqualTo(List.of(100, 98, 90));
assertThat(result.getHourlyBatteryLevelsPerDay().get(1).getTimestamps())
.isEqualTo(List.of(1691596800000L, 1691604000000L));
assertThat(result.getHourlyBatteryLevelsPerDay().get(1).getLevels())
.isEqualTo(List.of(90, 80));
}
@Test
public void combine_existingBatteryLevelDataIsNull_returnExpectedResult() {
final List<BatteryEvent> batteryLevelRecordEvents = List.of(
BatteryEvent.newBuilder().setTimestamp(1691586000166L).setBatteryLevel(100)
.setType(BatteryEventType.FULL_CHARGED).build(),
BatteryEvent.newBuilder().setTimestamp(1691589600000L).setBatteryLevel(98)
.setType(BatteryEventType.EVEN_HOUR).build());
BatteryLevelData result =
BatteryLevelData.combine(null, batteryLevelRecordEvents);
assertThat(result.getHourlyBatteryLevelsPerDay())
.hasSize(1);
assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getTimestamps())
.isEqualTo(List.of(1691586000166L, 1691589600000L));
assertThat(result.getHourlyBatteryLevelsPerDay().get(0).getLevels())
.isEqualTo(List.of(100, 98));
}
}

50
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownControllerTest.java
View File

@@ -96,6 +96,14 @@ public final class BatteryUsageBreakdownControllerTest {
mBatteryUsageBreakdownController.mAppListPreferenceGroup = mAppListPreferenceGroup;
mBatteryDiffEntry = new BatteryDiffEntry(
mContext,
/*uid=*/ 0L,
/*userId=*/ 0L,
/*key=*/ "key",
/*isHidden=*/ false,
/*componentId=*/ -1,
/*legacyPackageName=*/ null,
/*legacyLabel=*/ null,
/*consumerType=*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*foregroundUsageTimeInMs=*/ 1,
/*backgroundUsageTimeInMs=*/ 2,
/*screenOnTimeInMs=*/ 0,
@@ -103,13 +111,14 @@ public final class BatteryUsageBreakdownControllerTest {
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 1,
/*backgroundUsageConsumePower=*/ 2,
/*cachedUsageConsumePower=*/ 0,
mBatteryHistEntry);
/*cachedUsageConsumePower=*/ 0);
mBatteryDiffEntry = spy(mBatteryDiffEntry);
mBatteryUsageBreakdownController.mBatteryDiffData =
new BatteryDiffData(mContext, /* screenOnTime= */ 0L,
Arrays.asList(mBatteryDiffEntry), Arrays.asList(), Set.of(), Set.of(),
/* isAccumulated= */ false);
new BatteryDiffData(mContext, /* startTimestamp= */ 0L, /* endTimestamp= */ 0L,
/* startBatteryLevel= */ 0, /* endBatteryLevel= */ 0,
/* screenOnTime= */ 0L, Arrays.asList(mBatteryDiffEntry), Arrays.asList(),
Set.of(), Set.of(), /* isAccumulated= */ false);
BatteryDiffEntry.clearCache();
// Adds fake testing data.
BatteryDiffEntry.sResourceCache.put(
"fakeBatteryDiffEntryKey",
@@ -140,7 +149,7 @@ public final class BatteryUsageBreakdownControllerTest {
doReturn(1).when(mAppListPreferenceGroup).getPreferenceCount();
doReturn(mDrawable).when(mBatteryDiffEntry).getAppIcon();
doReturn(appLabel).when(mBatteryDiffEntry).getAppLabel();
doReturn(PREF_KEY).when(mBatteryHistEntry).getKey();
doReturn(PREF_KEY).when(mBatteryDiffEntry).getKey();
doReturn(null).when(mAppListPreferenceGroup).findPreference(PREF_KEY);
doReturn(false).when(mBatteryDiffEntry).validForRestriction();
@@ -168,7 +177,7 @@ public final class BatteryUsageBreakdownControllerTest {
doReturn(1).when(mAppListPreferenceGroup).getPreferenceCount();
doReturn(mDrawable).when(mBatteryDiffEntry).getAppIcon();
doReturn(appLabel).when(mBatteryDiffEntry).getAppLabel();
doReturn(PREF_KEY).when(mBatteryHistEntry).getKey();
doReturn(PREF_KEY).when(mBatteryDiffEntry).getKey();
doReturn(mPowerGaugePreference).when(mAppListPreferenceGroup).findPreference(PREF_KEY);
mBatteryUsageBreakdownController.addAllPreferences();
@@ -197,7 +206,7 @@ public final class BatteryUsageBreakdownControllerTest {
public void removeAndCacheAllUnusedPreferences_keepPref_KeepAllPreference() {
doReturn(1).when(mAppListPreferenceGroup).getPreferenceCount();
doReturn(mPowerGaugePreference).when(mAppListPreferenceGroup).getPreference(0);
doReturn(PREF_KEY).when(mBatteryHistEntry).getKey();
doReturn(PREF_KEY).when(mBatteryDiffEntry).getKey();
doReturn(PREF_KEY).when(mPowerGaugePreference).getKey();
doReturn(mPowerGaugePreference).when(mAppListPreferenceGroup).findPreference(PREF_KEY);
// Ensures the testing data is correct.
@@ -222,7 +231,7 @@ public final class BatteryUsageBreakdownControllerTest {
@Test
public void handlePreferenceTreeClick_forAppEntry_returnTrue() {
doReturn(false).when(mBatteryHistEntry).isAppEntry();
mBatteryDiffEntry.mConsumerType = ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY;
doReturn(mBatteryDiffEntry).when(mPowerGaugePreference).getBatteryDiffEntry();
assertThat(mBatteryUsageBreakdownController.handlePreferenceTreeClick(
@@ -238,7 +247,7 @@ public final class BatteryUsageBreakdownControllerTest {
@Test
public void handlePreferenceTreeClick_forSystemEntry_returnTrue() {
doReturn(true).when(mBatteryHistEntry).isAppEntry();
mBatteryDiffEntry.mConsumerType = ConvertUtils.CONSUMER_TYPE_UID_BATTERY;
doReturn(mBatteryDiffEntry).when(mPowerGaugePreference).getBatteryDiffEntry();
assertThat(mBatteryUsageBreakdownController.handlePreferenceTreeClick(
@@ -394,10 +403,23 @@ public final class BatteryUsageBreakdownControllerTest {
contentValues.put(BatteryHistEntry.KEY_USER_ID, Integer.valueOf(1001));
final BatteryHistEntry batteryHistEntry = new BatteryHistEntry(contentValues);
return new BatteryDiffEntry(
mContext, foregroundUsageTimeInMs, backgroundUsageTimeInMs, screenOnTimeInMs,
/*consumePower=*/ 0, /*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0, /*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0, batteryHistEntry);
mContext,
batteryHistEntry.mUid,
batteryHistEntry.mUserId,
batteryHistEntry.getKey(),
batteryHistEntry.mIsHidden,
batteryHistEntry.mDrainType,
batteryHistEntry.mPackageName,
batteryHistEntry.mAppLabel,
batteryHistEntry.mConsumerType,
foregroundUsageTimeInMs,
backgroundUsageTimeInMs,
screenOnTimeInMs,
/*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0);
}
private BatteryUsageBreakdownController createController() {

187
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java
View File

@@ -20,11 +20,9 @@ import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
import android.app.Application;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
@@ -34,6 +32,7 @@ import com.android.settings.fuelgauge.batteryusage.db.AppUsageEventEntity;
import com.android.settings.fuelgauge.batteryusage.db.BatteryEventEntity;
import com.android.settings.fuelgauge.batteryusage.db.BatteryState;
import com.android.settings.fuelgauge.batteryusage.db.BatteryStateDatabase;
import com.android.settings.fuelgauge.batteryusage.db.BatteryUsageSlotEntity;
import com.android.settings.testutils.BatteryTestUtils;
import com.android.settings.testutils.FakeClock;
@@ -41,12 +40,10 @@ import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.Shadows;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/** Tests for {@link BatteryUsageContentProvider}. */
@@ -126,11 +123,29 @@ public final class BatteryUsageContentProviderTest {
() -> mProvider.insert(uri, /*contentValues=*/ null));
}
@Test
public void query_getLastFullChargeTimestamp_returnsExpectedResult() throws Exception {
mProvider.onCreate();
ContentValues values = new ContentValues();
values.put(BatteryEventEntity.KEY_TIMESTAMP, 10001L);
values.put(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE,
BatteryEventType.FULL_CHARGED.getNumber());
values.put(BatteryEventEntity.KEY_BATTERY_LEVEL, 100);
mProvider.insert(DatabaseUtils.BATTERY_EVENT_URI, values);
final Cursor cursor = getCursorOfLastFullChargeTimestamp();
assertThat(cursor.getCount()).isEqualTo(1);
cursor.moveToFirst();
final long lastFullChargeTimestamp = cursor.getLong(0);
assertThat(lastFullChargeTimestamp).isEqualTo(10001L);
}
@Test
public void query_batteryState_returnsExpectedResult() throws Exception {
mProvider.onCreate();
final Duration currentTime = Duration.ofHours(52);
final long expiredTimeCutoff = currentTime.toMillis() - 3;
final long expiredTimeCutoff = currentTime.toMillis() - 8;
final Cursor cursor = insertBatteryState(currentTime, Long.toString(expiredTimeCutoff));
@@ -150,19 +165,13 @@ public final class BatteryUsageContentProviderTest {
final String actualPackageName3 = cursor.getString(packageNameIndex);
assertThat(actualPackageName3).isEqualTo(PACKAGE_NAME3);
cursor.close();
// Verifies the broadcast intent.
TimeUnit.SECONDS.sleep(1);
final List<Intent> intents = Shadows.shadowOf((Application) mContext).getBroadcastIntents();
assertThat(intents).hasSize(1);
assertThat(intents.get(0).getAction()).isEqualTo(
BootBroadcastReceiver.ACTION_PERIODIC_JOB_RECHECK);
}
@Test
public void query_batteryStateTimestamp_returnsExpectedResult() throws Exception {
mProvider.onCreate();
final Duration currentTime = Duration.ofHours(52);
final long expiredTimeCutoff = currentTime.toMillis() - 1;
final long expiredTimeCutoff = currentTime.toMillis() - 2;
final Cursor cursor = insertBatteryState(currentTime, Long.toString(expiredTimeCutoff));
@@ -178,12 +187,25 @@ public final class BatteryUsageContentProviderTest {
final String actualPackageName2 = cursor.getString(packageNameIndex);
assertThat(actualPackageName2).isEqualTo(PACKAGE_NAME3);
cursor.close();
// Verifies the broadcast intent.
TimeUnit.SECONDS.sleep(1);
final List<Intent> intents = Shadows.shadowOf((Application) mContext).getBroadcastIntents();
assertThat(intents).hasSize(1);
assertThat(intents.get(0).getAction()).isEqualTo(
BootBroadcastReceiver.ACTION_PERIODIC_JOB_RECHECK);
}
@Test
public void query_getBatteryStateLatestTimestamp_returnsExpectedResult() throws Exception {
mProvider.onCreate();
final Duration currentTime = Duration.ofHours(52);
insertBatteryState(currentTime, Long.toString(currentTime.toMillis()));
final Cursor cursor1 = getCursorOfBatteryStateLatestTimestamp(currentTime.toMillis() - 5);
assertThat(cursor1.getCount()).isEqualTo(1);
cursor1.moveToFirst();
final long latestTimestamp1 = cursor1.getLong(0);
assertThat(latestTimestamp1).isEqualTo(currentTime.toMillis() - 6);
final Cursor cursor2 = getCursorOfBatteryStateLatestTimestamp(currentTime.toMillis() - 2);
assertThat(cursor2.getCount()).isEqualTo(1);
cursor2.moveToFirst();
final long latestTimestamp2 = cursor2.getLong(0);
assertThat(latestTimestamp2).isEqualTo(currentTime.toMillis() - 2);
}
@Test
@@ -355,7 +377,7 @@ public final class BatteryUsageContentProviderTest {
}
@Test
public void insert_batteryEvent_returnsExpectedResult() {
public void insertAndQuery_batteryEvent_returnsExpectedResult() {
mProvider.onCreate();
ContentValues values = new ContentValues();
values.put(BatteryEventEntity.KEY_TIMESTAMP, 10001L);
@@ -366,7 +388,7 @@ public final class BatteryUsageContentProviderTest {
final Uri uri = mProvider.insert(DatabaseUtils.BATTERY_EVENT_URI, values);
assertThat(uri).isEqualTo(DatabaseUtils.BATTERY_EVENT_URI);
// Verifies the AppUsageEventEntity content.
// Verifies the BatteryEventEntity content.
final List<BatteryEventEntity> entities =
BatteryStateDatabase.getInstance(mContext).batteryEventDao().getAll();
assertThat(entities).hasSize(1);
@@ -374,6 +396,50 @@ public final class BatteryUsageContentProviderTest {
assertThat(entities.get(0).batteryEventType).isEqualTo(
BatteryEventType.POWER_CONNECTED.getNumber());
assertThat(entities.get(0).batteryLevel).isEqualTo(66);
final Cursor cursor1 = getCursorOfBatteryEvents(
0L, List.of(BatteryEventType.POWER_CONNECTED.getNumber()));
assertThat(cursor1.getCount()).isEqualTo(1);
cursor1.moveToFirst();
assertThat(cursor1.getLong(cursor1.getColumnIndex(BatteryEventEntity.KEY_TIMESTAMP)))
.isEqualTo(10001L);
assertThat(
cursor1.getInt(cursor1.getColumnIndex(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE)))
.isEqualTo(BatteryEventType.POWER_CONNECTED.getNumber());
assertThat(cursor1.getInt(cursor1.getColumnIndex(BatteryEventEntity.KEY_BATTERY_LEVEL)))
.isEqualTo(66);
final Cursor cursor2 = getCursorOfBatteryEvents(
0L, List.of(BatteryEventType.POWER_DISCONNECTED.getNumber()));
assertThat(cursor2.getCount()).isEqualTo(0);
}
@Test
public void insertAndQuery_batteryUsageSlot_returnsExpectedResult() {
mProvider.onCreate();
ContentValues values = new ContentValues();
values.put(BatteryUsageSlotEntity.KEY_TIMESTAMP, 10001L);
values.put(BatteryUsageSlotEntity.KEY_BATTERY_USAGE_SLOT, "TEST_STRING");
final Uri uri = mProvider.insert(DatabaseUtils.BATTERY_USAGE_SLOT_URI, values);
// Verifies the BatteryUsageSlotEntity content.
assertThat(uri).isEqualTo(DatabaseUtils.BATTERY_USAGE_SLOT_URI);
final List<BatteryUsageSlotEntity> entities =
BatteryStateDatabase.getInstance(mContext).batteryUsageSlotDao().getAll();
assertThat(entities).hasSize(1);
assertThat(entities.get(0).timestamp).isEqualTo(10001L);
assertThat(entities.get(0).batteryUsageSlot).isEqualTo("TEST_STRING");
final Cursor cursor1 = getCursorOfBatteryUsageSlots(10001L);
assertThat(cursor1.getCount()).isEqualTo(1);
cursor1.moveToFirst();
assertThat(cursor1.getLong(cursor1.getColumnIndex(BatteryUsageSlotEntity.KEY_TIMESTAMP)))
.isEqualTo(10001L);
assertThat(cursor1.getString(cursor1.getColumnIndex(
BatteryUsageSlotEntity.KEY_BATTERY_USAGE_SLOT))).isEqualTo("TEST_STRING");
final Cursor cursor2 = getCursorOfBatteryUsageSlots(10002L);
assertThat(cursor2.getCount()).isEqualTo(0);
}
@Test
@@ -404,10 +470,10 @@ public final class BatteryUsageContentProviderTest {
final long currentTimestamp = currentTime.toMillis();
// Inserts some valid testing data.
BatteryTestUtils.insertDataToBatteryStateTable(
mContext, currentTimestamp - 2, PACKAGE_NAME1,
mContext, currentTimestamp - 6, PACKAGE_NAME1,
/*isFullChargeStart=*/ true);
BatteryTestUtils.insertDataToBatteryStateTable(
mContext, currentTimestamp - 1, PACKAGE_NAME2);
mContext, currentTimestamp - 2, PACKAGE_NAME2);
BatteryTestUtils.insertDataToBatteryStateTable(
mContext, currentTimestamp, PACKAGE_NAME3);
@@ -420,17 +486,35 @@ public final class BatteryUsageContentProviderTest {
DatabaseUtils.QUERY_KEY_TIMESTAMP, queryTimestamp)
.build();
final Cursor cursor =
mProvider.query(
batteryStateQueryContentUri,
/*strings=*/ null,
/*s=*/ null,
/*strings1=*/ null,
/*s1=*/ null);
final Cursor cursor = query(batteryStateQueryContentUri);
return cursor;
}
private Cursor getCursorOfLastFullChargeTimestamp() {
final Uri lastFullChargeTimestampContentUri =
new Uri.Builder()
.scheme(ContentResolver.SCHEME_CONTENT)
.authority(DatabaseUtils.AUTHORITY)
.appendPath(DatabaseUtils.LAST_FULL_CHARGE_TIMESTAMP_PATH)
.build();
return query(lastFullChargeTimestampContentUri);
}
private Cursor getCursorOfBatteryStateLatestTimestamp(final long queryTimestamp) {
final Uri batteryStateLatestTimestampUri =
new Uri.Builder()
.scheme(ContentResolver.SCHEME_CONTENT)
.authority(DatabaseUtils.AUTHORITY)
.appendPath(DatabaseUtils.BATTERY_STATE_LATEST_TIMESTAMP_PATH)
.appendQueryParameter(
DatabaseUtils.QUERY_KEY_TIMESTAMP, Long.toString(queryTimestamp))
.build();
return query(batteryStateLatestTimestampUri);
}
private void insertAppUsageEvent() {
mProvider.onCreate();
// Inserts some valid testing data.
@@ -452,12 +536,7 @@ public final class BatteryUsageContentProviderTest {
DatabaseUtils.QUERY_KEY_USERID, Long.toString(userId))
.build();
return mProvider.query(
appUsageLatestTimestampQueryContentUri,
/*strings=*/ null,
/*s=*/ null,
/*strings1=*/ null,
/*s1=*/ null);
return query(appUsageLatestTimestampQueryContentUri);
}
private Cursor getCursorOfAppUsage(final List<Long> userIds, final long queryTimestamp) {
@@ -474,7 +553,43 @@ public final class BatteryUsageContentProviderTest {
.appendQueryParameter(DatabaseUtils.QUERY_KEY_USERID, queryUserIdString)
.build();
return query(appUsageEventUri);
}
private Cursor getCursorOfBatteryEvents(
final long queryTimestamp, final List<Integer> batteryEventTypes) {
final String batteryEventTypesString = batteryEventTypes.stream()
.map(type -> String.valueOf(type))
.collect(Collectors.joining(","));
final Uri batteryEventUri =
new Uri.Builder()
.scheme(ContentResolver.SCHEME_CONTENT)
.authority(DatabaseUtils.AUTHORITY)
.appendPath(DatabaseUtils.BATTERY_EVENT_TABLE)
.appendQueryParameter(
DatabaseUtils.QUERY_KEY_TIMESTAMP, Long.toString(queryTimestamp))
.appendQueryParameter(
DatabaseUtils.QUERY_BATTERY_EVENT_TYPE, batteryEventTypesString)
.build();
return query(batteryEventUri);
}
private Cursor getCursorOfBatteryUsageSlots(final long queryTimestamp) {
final Uri batteryUsageSlotUri =
new Uri.Builder()
.scheme(ContentResolver.SCHEME_CONTENT)
.authority(DatabaseUtils.AUTHORITY)
.appendPath(DatabaseUtils.BATTERY_USAGE_SLOT_TABLE)
.appendQueryParameter(
DatabaseUtils.QUERY_KEY_TIMESTAMP, Long.toString(queryTimestamp))
.build();
return query(batteryUsageSlotUri);
}
private Cursor query(Uri uri) {
return mProvider.query(
appUsageEventUri, /*strings=*/ null, /*s=*/ null, /*strings1=*/ null, /*s1=*/ null);
uri, /*strings=*/ null, /*s=*/ null, /*strings1=*/ null, /*s1=*/ null);
}
}

55
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageDataLoaderTest.java
View File

@@ -22,6 +22,7 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import android.content.ContentResolver;
@@ -31,6 +32,7 @@ import android.content.pm.PackageManager;
import android.os.BatteryStatsManager;
import android.os.BatteryUsageStats;
import android.os.BatteryUsageStatsQuery;
import android.os.UserManager;
import org.junit.Before;
import org.junit.Test;
@@ -43,6 +45,7 @@ import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
@@ -56,6 +59,8 @@ public final class BatteryUsageDataLoaderTest {
@Mock
private PackageManager mPackageManager;
@Mock
private UserManager mUserManager;
@Mock
private BatteryUsageStats mBatteryUsageStats;
@Mock
private BatteryEntry mMockBatteryEntry;
@@ -70,6 +75,7 @@ public final class BatteryUsageDataLoaderTest {
doReturn(mBatteryStatsManager).when(mContext).getSystemService(
Context.BATTERY_STATS_SERVICE);
doReturn(mPackageManager).when(mContext).getPackageManager();
doReturn(mUserManager).when(mContext).getSystemService(UserManager.class);
doReturn(mMockContentResolver).when(mContext).getContentResolver();
doReturn(new Intent()).when(mContext).registerReceiver(any(), any());
}
@@ -82,7 +88,7 @@ public final class BatteryUsageDataLoaderTest {
.thenReturn(mBatteryUsageStats);
BatteryUsageDataLoader.sFakeBatteryEntryListSupplier = () -> batteryEntryList;
BatteryUsageDataLoader.loadUsageData(mContext, /*isFullChargeStart=*/ false);
BatteryUsageDataLoader.loadBatteryStatsData(mContext, /*isFullChargeStart=*/ false);
final int queryFlags = mStatsQueryCaptor.getValue().getFlags();
assertThat(queryFlags
@@ -97,7 +103,7 @@ public final class BatteryUsageDataLoaderTest {
.thenReturn(mBatteryUsageStats);
BatteryUsageDataLoader.sFakeBatteryEntryListSupplier = () -> null;
BatteryUsageDataLoader.loadUsageData(mContext, /*isFullChargeStart=*/ false);
BatteryUsageDataLoader.loadBatteryStatsData(mContext, /*isFullChargeStart=*/ false);
verify(mMockContentResolver).insert(any(), any());
}
@@ -108,8 +114,51 @@ public final class BatteryUsageDataLoaderTest {
.thenReturn(mBatteryUsageStats);
BatteryUsageDataLoader.sFakeBatteryEntryListSupplier = () -> new ArrayList<>();
BatteryUsageDataLoader.loadUsageData(mContext, /*isFullChargeStart=*/ false);
BatteryUsageDataLoader.loadBatteryStatsData(mContext, /*isFullChargeStart=*/ false);
verify(mMockContentResolver).insert(any(), any());
}
@Test
public void loadAppUsageData_withData_insertFakeDataIntoProvider() {
final List<AppUsageEvent> AppUsageEventList = new ArrayList<>();
final AppUsageEvent appUsageEvent = AppUsageEvent.newBuilder().setUid(0).build();
AppUsageEventList.add(appUsageEvent);
BatteryUsageDataLoader.sFakeAppUsageEventsSupplier = () -> new HashMap<>();
BatteryUsageDataLoader.sFakeUsageEventsListSupplier = () -> AppUsageEventList;
BatteryUsageDataLoader.loadAppUsageData(mContext);
verify(mMockContentResolver).bulkInsert(any(), any());
verify(mMockContentResolver).notifyChange(any(), any());
}
@Test
public void loadAppUsageData_nullAppUsageEvents_notInsertDataIntoProvider() {
BatteryUsageDataLoader.sFakeAppUsageEventsSupplier = () -> null;
BatteryUsageDataLoader.loadAppUsageData(mContext);
verifyNoMoreInteractions(mMockContentResolver);
}
@Test
public void loadAppUsageData_nullUsageEventsList_notInsertDataIntoProvider() {
BatteryUsageDataLoader.sFakeAppUsageEventsSupplier = () -> new HashMap<>();
BatteryUsageDataLoader.sFakeUsageEventsListSupplier = () -> null;
BatteryUsageDataLoader.loadAppUsageData(mContext);
verifyNoMoreInteractions(mMockContentResolver);
}
@Test
public void loadAppUsageData_emptyUsageEventsList_notInsertDataIntoProvider() {
BatteryUsageDataLoader.sFakeAppUsageEventsSupplier = () -> new HashMap<>();
BatteryUsageDataLoader.sFakeUsageEventsListSupplier = () -> new ArrayList<>();
BatteryUsageDataLoader.loadAppUsageData(mContext);
verifyNoMoreInteractions(mMockContentResolver);
}
}

64
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java
View File

@@ -39,6 +39,7 @@ import android.os.UserHandle;
import com.android.settings.fuelgauge.batteryusage.db.AppUsageEventEntity;
import com.android.settings.fuelgauge.batteryusage.db.BatteryEventEntity;
import com.android.settings.fuelgauge.batteryusage.db.BatteryUsageSlotEntity;
import org.junit.Before;
import org.junit.Test;
@@ -48,7 +49,10 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
@RunWith(RobolectricTestRunner.class)
@@ -212,6 +216,22 @@ public final class ConvertUtilsTest {
assertThat(values.getAsInteger(BatteryEventEntity.KEY_BATTERY_LEVEL)).isEqualTo(66);
}
@Test
public void convertBatteryUsageSlotToContentValues_normalCase_returnsExpectedContentValues() {
final BatteryUsageSlot batteryUsageSlot =
BatteryUsageSlot.newBuilder()
.setStartTimestamp(10001L)
.setEndTimestamp(30003L)
.setStartBatteryLevel(88)
.setEndBatteryLevel(66)
.setScreenOnTime(123L)
.build();
final ContentValues values =
ConvertUtils.convertBatteryUsageSlotToContentValues(batteryUsageSlot);
assertThat(values.getAsLong(BatteryUsageSlotEntity.KEY_TIMESTAMP)).isEqualTo(10001L);
assertThat(BatteryUsageSlotEntity.KEY_BATTERY_USAGE_SLOT).isNotEmpty();
}
@Test
public void convertToBatteryHistEntry_returnsExpectedResult() {
final int expectedType = 3;
@@ -363,7 +383,7 @@ public final class ConvertUtilsTest {
}
@Test
public void convertToAppUsageEventFromCursor_returnExpectedResult() {
public void convertToAppUsageEvent_returnExpectedResult() {
final MatrixCursor cursor = new MatrixCursor(
new String[]{
AppUsageEventEntity.KEY_UID,
@@ -384,7 +404,7 @@ public final class ConvertUtilsTest {
100001L});
cursor.moveToFirst();
final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEventFromCursor(cursor);
final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEvent(cursor);
assertThat(appUsageEvent.getUid()).isEqualTo(101L);
assertThat(appUsageEvent.getUserId()).isEqualTo(1001L);
@@ -396,7 +416,7 @@ public final class ConvertUtilsTest {
}
@Test
public void convertToAppUsageEventFromCursor_emptyInstanceIdAndRootName_returnExpectedResult() {
public void convertToAppUsageEvent_emptyInstanceIdAndRootName_returnExpectedResult() {
final MatrixCursor cursor = new MatrixCursor(
new String[]{
AppUsageEventEntity.KEY_UID,
@@ -413,7 +433,7 @@ public final class ConvertUtilsTest {
AppUsageEventType.DEVICE_SHUTDOWN.getNumber()});
cursor.moveToFirst();
final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEventFromCursor(cursor);
final AppUsageEvent appUsageEvent = ConvertUtils.convertToAppUsageEvent(cursor);
assertThat(appUsageEvent.getUid()).isEqualTo(101L);
assertThat(appUsageEvent.getUserId()).isEqualTo(1001L);
@@ -433,6 +453,42 @@ public final class ConvertUtilsTest {
assertThat(batteryEvent.getBatteryLevel()).isEqualTo(88);
}
@Test
public void convertToBatteryEventList_normalCase_returnsExpectedResult() {
final BatteryLevelData batteryLevelData = new BatteryLevelData(Map.of(
1691589600000L, 98, 1691596800000L, 90, 1691596812345L, 80));
final List<BatteryEvent> batteryEventList =
ConvertUtils.convertToBatteryEventList(batteryLevelData);
assertThat(batteryEventList).hasSize(2);
assertThat(batteryEventList.get(0).getTimestamp()).isEqualTo(1691589600000L);
assertThat(batteryEventList.get(0).getType()).isEqualTo(BatteryEventType.EVEN_HOUR);
assertThat(batteryEventList.get(0).getBatteryLevel()).isEqualTo(98);
assertThat(batteryEventList.get(1).getTimestamp()).isEqualTo(1691596800000L);
assertThat(batteryEventList.get(1).getType()).isEqualTo(BatteryEventType.EVEN_HOUR);
assertThat(batteryEventList.get(1).getBatteryLevel()).isEqualTo(90);
}
@Test
public void convertToBatteryUsageSlotList_normalCase_returnsExpectedResult() {
BatteryDiffData batteryDiffData1 = new BatteryDiffData(
mContext, 11L, 12L, 13, 14, 15, List.of(), List.of(), Set.of(), Set.of(), false);
BatteryDiffData batteryDiffData2 = new BatteryDiffData(
mContext, 21L, 22L, 23, 24, 25, List.of(), List.of(), Set.of(), Set.of(), false);
BatteryDiffData batteryDiffData3 = new BatteryDiffData(
mContext, 31L, 32L, 33, 34, 35, List.of(), List.of(), Set.of(), Set.of(), false);
final Map<Long, BatteryDiffData> batteryDiffDataMap = Map.of(
11L, batteryDiffData1, 21L, batteryDiffData2, 31L, batteryDiffData3);
final List<BatteryUsageSlot> batteryUsageSlotList =
ConvertUtils.convertToBatteryUsageSlotList(batteryDiffDataMap);
assertThat(batteryUsageSlotList).hasSize(3);
assertThat(batteryUsageSlotList.stream().map((s) -> s.getScreenOnTime()).sorted().toList())
.isEqualTo(List.of(15L, 25L, 35L));
}
@Test
public void getLocale_nullContext_returnDefaultLocale() {
assertThat(ConvertUtils.getLocale(/*context=*/ null))

72
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessManagerTest.java
View File

@@ -30,8 +30,12 @@ import android.app.usage.UsageEvents;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.os.BatteryManager;
import android.os.BatteryStatsManager;
import android.os.BatteryUsageStats;
import android.os.BatteryUsageStatsQuery;
import android.os.Parcel;
import android.os.RemoteException;
import android.os.UserManager;
@@ -39,9 +43,12 @@ import android.text.format.DateUtils;
import com.android.settings.fuelgauge.batteryusage.db.AppUsageEventEntity;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
@@ -52,6 +59,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
@RunWith(RobolectricTestRunner.class)
public final class DataProcessManagerTest {
@@ -65,7 +73,13 @@ public final class DataProcessManagerTest {
@Mock
private UserManager mUserManager;
@Mock
private BatteryStatsManager mBatteryStatsManager;
@Mock
private BatteryUsageStats mBatteryUsageStats;
@Mock
private Intent mIntent;
@Captor
private ArgumentCaptor<BatteryUsageStatsQuery> mBatteryUsageStatsQueryCaptor;
@Before
public void setUp() {
@@ -77,22 +91,32 @@ public final class DataProcessManagerTest {
doReturn(mUserManager)
.when(mContext)
.getSystemService(UserManager.class);
doReturn(mBatteryStatsManager).when(mContext).getSystemService(
Context.BATTERY_STATS_SERVICE);
doReturn(mBatteryUsageStats).when(
mBatteryStatsManager).getBatteryUsageStats(mBatteryUsageStatsQueryCaptor.capture());
doReturn(mIntent).when(mContext).registerReceiver(any(), any());
doReturn(100).when(mIntent).getIntExtra(eq(BatteryManager.EXTRA_SCALE), anyInt());
doReturn(66).when(mIntent).getIntExtra(eq(BatteryManager.EXTRA_LEVEL), anyInt());
mDataProcessManager = new DataProcessManager(
mContext, /*handler=*/ null, /*rawStartTimestamp=*/ 0L,
/*callbackFunction=*/ null, /*hourlyBatteryLevelsPerDay=*/ new ArrayList<>(),
/*lastFullChargeTimestamp=*/ 0L, /*callbackFunction=*/ null,
/*hourlyBatteryLevelsPerDay=*/ new ArrayList<>(),
/*batteryHistoryMap=*/ new HashMap<>());
}
@After
public void cleanUp() {
DatabaseUtils.sFakeSupplier = null;
DataProcessManager.sFakeBatteryHistoryMap = null;
}
@Test
public void constructor_noLevelData() {
final DataProcessManager dataProcessManager =
new DataProcessManager(mContext, /*handler=*/ null, /*callbackFunction=*/ null);
assertThat(dataProcessManager.getShowScreenOnTime()).isFalse();
assertThat(dataProcessManager.getShowBatteryLevel()).isFalse();
}
@Test
@@ -122,16 +146,18 @@ public final class DataProcessManagerTest {
final String packageName = "package";
// Adds the day 1 data.
final List<Long> timestamps1 = List.of(2L, 3L, 4L);
final List<Integer> levels1 = List.of(100, 100, 100);
final Map<Long, Integer> batteryLevelMap1 =
Map.of(timestamps1.get(0), 100, timestamps1.get(1), 100, timestamps1.get(2), 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps1, levels1));
new BatteryLevelData.PeriodBatteryLevelData(batteryLevelMap1, timestamps1));
// Adds the day 2 data.
hourlyBatteryLevelsPerDay.add(null);
// Adds the day 3 data.
final List<Long> timestamps2 = List.of(5L, 6L);
final List<Integer> levels2 = List.of(100, 100);
final Map<Long, Integer> batteryLevelMap2 =
Map.of(timestamps2.get(0), 100, timestamps2.get(1), 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps2, levels2));
new BatteryLevelData.PeriodBatteryLevelData(batteryLevelMap2, timestamps2));
// Fake current usage data.
final UsageEvents.Event event1 =
getUsageEvent(UsageEvents.Event.ACTIVITY_RESUMED, /*timestamp=*/ 1, packageName);
@@ -171,10 +197,18 @@ public final class DataProcessManagerTest {
cursor.addRow(new Object[] {
AppUsageEventType.ACTIVITY_STOPPED.getNumber(), /*timestamp=*/ 6, /*userId=*/ 1,
/*instanceId=*/ 2, packageName});
DatabaseUtils.sFakeSupplier = () -> cursor;
DatabaseUtils.sFakeSupplier = new Supplier<>() {
private int mTimes = 0;
@Override
public Cursor get() {
mTimes++;
return mTimes <= 2 ? null : cursor;
}
};
final DataProcessManager dataProcessManager = new DataProcessManager(
mContext, /*handler=*/ null, /*rawStartTimestamp=*/ 2L, /*callbackFunction=*/ null,
mContext, /*handler=*/ null, /*rawStartTimestamp=*/ 2L,
/*lastFullChargeTimestamp=*/ 1L, /*callbackFunction=*/ null,
hourlyBatteryLevelsPerDay, /*batteryHistoryMap=*/ new HashMap<>());
dataProcessManager.start();
@@ -254,12 +288,13 @@ public final class DataProcessManagerTest {
assertThat(DataProcessManager.getBatteryLevelData(
mContext,
/*handler=*/ null,
/*batteryHistoryMap=*/ null,
/*asyncResponseDelegate=*/ null))
.isNull();
/*isFromPeriodJob=*/ false,
/*asyncResponseDelegate=*/ null)).isNull();
assertThat(DataProcessManager.getBatteryLevelData(
mContext, /*handler=*/ null, new HashMap<>(), /*asyncResponseDelegate=*/ null))
.isNull();
mContext,
/*handler=*/ null,
/*isFromPeriodJob=*/ true,
/*asyncResponseDelegate=*/ null)).isNull();
}
@Test
@@ -270,18 +305,16 @@ public final class DataProcessManagerTest {
DateUtils.HOUR_IN_MILLIS * 2 - 200L,
DateUtils.HOUR_IN_MILLIS * 2 - 100L};
final int[] levels = {100, 99, 98};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap =
createHistoryMap(timestamps, levels);
DataProcessManager.sFakeBatteryHistoryMap = createHistoryMap(timestamps, levels);
DataProcessor.sTestCurrentTimeMillis = timestamps[timestamps.length - 1];
final BatteryLevelData resultData =
DataProcessManager.getBatteryLevelData(
mContext,
/*handler=*/ null,
batteryHistoryMap,
/*isFromPeriodJob=*/ false,
/*asyncResponseDelegate=*/ null);
final List<Long> expectedDailyTimestamps = List.of(
DateUtils.HOUR_IN_MILLIS * 2 - 300L,
DateUtils.HOUR_IN_MILLIS * 2 - 100L);
@@ -301,15 +334,14 @@ public final class DataProcessManagerTest {
// Timezone GMT+8: 2022-01-01 00:00:00, 2022-01-01 01:00:00
final long[] timestamps = {1640966400000L, 1640970000000L};
final int[] levels = {100, 99};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap =
createHistoryMap(timestamps, levels);
DataProcessManager.sFakeBatteryHistoryMap = createHistoryMap(timestamps, levels);
DataProcessor.sTestCurrentTimeMillis = timestamps[timestamps.length - 1];
final BatteryLevelData resultData =
DataProcessManager.getBatteryLevelData(
mContext,
/*handler=*/ null,
batteryHistoryMap,
/*isFromPeriodJob=*/ false,
/*asyncResponseDelegate=*/ null);
final List<Long> expectedDailyTimestamps = List.of(

428
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessorTest.java
View File

@@ -16,6 +16,9 @@
package com.android.settings.fuelgauge.batteryusage;
import static com.android.settings.fuelgauge.batteryusage.ConvertUtils.FAKE_PACKAGE_NAME;
import static com.android.settingslib.fuelgauge.BatteryStatus.BATTERY_LEVEL_UNKNOWN;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.anyInt;
@@ -42,6 +45,7 @@ import android.os.BatteryUsageStats;
import android.os.Parcel;
import android.os.RemoteException;
import android.os.UserManager;
import android.util.ArrayMap;
import com.android.settings.fuelgauge.PowerUsageFeatureProvider;
import com.android.settings.testutils.FakeFeatureFactory;
@@ -188,16 +192,18 @@ public final class DataProcessorTest {
final String packageName = "com.android.settings";
// Adds the day 1 data.
final List<Long> timestamps1 = List.of(14400000L, 18000000L, 21600000L);
final List<Integer> levels1 = List.of(100, 100, 100);
final Map<Long, Integer> batteryLevelMap1 =
Map.of(timestamps1.get(0), 100, timestamps1.get(1), 100, timestamps1.get(2), 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps1, levels1));
new BatteryLevelData.PeriodBatteryLevelData(batteryLevelMap1, timestamps1));
// Adds the day 2 data.
hourlyBatteryLevelsPerDay.add(null);
// Adds the day 3 data.
final List<Long> timestamps2 = List.of(45200000L, 48800000L);
final List<Integer> levels2 = List.of(100, 100);
final Map<Long, Integer> batteryLevelMap2 =
Map.of(timestamps2.get(0), 100, timestamps2.get(1), 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps2, levels2));
new BatteryLevelData.PeriodBatteryLevelData(batteryLevelMap2, timestamps2));
final List<AppUsageEvent> appUsageEventList = new ArrayList<>();
// Adds some events before the start timestamp.
appUsageEventList.add(buildAppUsageEvent(
@@ -285,7 +291,7 @@ public final class DataProcessorTest {
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(new ArrayList<>(), new ArrayList<>()));
new BatteryLevelData.PeriodBatteryLevelData(new ArrayMap<>(), new ArrayList<>()));
assertThat(DataProcessor.generateAppUsagePeriodMap(
mContext, hourlyBatteryLevelsPerDay, new ArrayList<>(), new ArrayList<>()))
.isNull();
@@ -370,19 +376,6 @@ public final class DataProcessorTest {
DataProcessor.CURRENT_TIME_BATTERY_HISTORY_PLACEHOLDER)).isTrue();
}
@Test
public void getLevelDataThroughProcessedHistoryMap_notEnoughData_returnNull() {
final long[] timestamps = {100L};
final int[] levels = {100};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap =
createHistoryMap(timestamps, levels);
DataProcessor.sTestCurrentTimeMillis = timestamps[timestamps.length - 1];
assertThat(
DataProcessor.getLevelDataThroughProcessedHistoryMap(mContext, batteryHistoryMap))
.isNull();
}
@Test
public void getLevelDataThroughProcessedHistoryMap_OneDayData_returnExpectedResult() {
// Timezone GMT+8
@@ -441,7 +434,7 @@ public final class DataProcessorTest {
);
final List<Integer> expectedDailyLevels = new ArrayList<>();
expectedDailyLevels.add(100);
expectedDailyLevels.add(null);
expectedDailyLevels.add(BATTERY_LEVEL_UNKNOWN);
expectedDailyLevels.add(82);
final List<List<Long>> expectedHourlyTimestamps = List.of(
List.of(
@@ -459,13 +452,13 @@ public final class DataProcessorTest {
);
final List<Integer> expectedHourlyLevels1 = new ArrayList<>();
expectedHourlyLevels1.add(100);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
final List<Integer> expectedHourlyLevels2 = new ArrayList<>();
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(94);
expectedHourlyLevels2.add(90);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(82);
final List<List<Integer>> expectedHourlyLevels = List.of(
expectedHourlyLevels1,
@@ -503,8 +496,8 @@ public final class DataProcessorTest {
);
final List<Integer> expectedDailyLevels = new ArrayList<>();
expectedDailyLevels.add(100);
expectedDailyLevels.add(null);
expectedDailyLevels.add(null);
expectedDailyLevels.add(BATTERY_LEVEL_UNKNOWN);
expectedDailyLevels.add(BATTERY_LEVEL_UNKNOWN);
expectedDailyLevels.add(88);
final List<List<Long>> expectedHourlyTimestamps = List.of(
List.of(
@@ -542,32 +535,32 @@ public final class DataProcessorTest {
);
final List<Integer> expectedHourlyLevels1 = new ArrayList<>();
expectedHourlyLevels1.add(100);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
final List<Integer> expectedHourlyLevels2 = new ArrayList<>();
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
final List<Integer> expectedHourlyLevels3 = new ArrayList<>();
expectedHourlyLevels3.add(null);
expectedHourlyLevels3.add(null);
expectedHourlyLevels3.add(null);
expectedHourlyLevels3.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels3.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels3.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels3.add(88);
final List<List<Integer>> expectedHourlyLevels = List.of(
expectedHourlyLevels1,
@@ -606,8 +599,8 @@ public final class DataProcessorTest {
);
final List<Integer> expectedDailyLevels = new ArrayList<>();
expectedDailyLevels.add(100);
expectedDailyLevels.add(null);
expectedDailyLevels.add(null);
expectedDailyLevels.add(BATTERY_LEVEL_UNKNOWN);
expectedDailyLevels.add(BATTERY_LEVEL_UNKNOWN);
expectedDailyLevels.add(88);
final List<List<Long>> expectedHourlyTimestamps = List.of(
List.of(
@@ -638,25 +631,25 @@ public final class DataProcessorTest {
);
final List<Integer> expectedHourlyLevels1 = new ArrayList<>();
expectedHourlyLevels1.add(100);
expectedHourlyLevels1.add(null);
expectedHourlyLevels1.add(BATTERY_LEVEL_UNKNOWN);
final List<Integer> expectedHourlyLevels2 = new ArrayList<>();
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(null);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels2.add(BATTERY_LEVEL_UNKNOWN);
final List<Integer> expectedHourlyLevels3 = new ArrayList<>();
expectedHourlyLevels3.add(null);
expectedHourlyLevels3.add(null);
expectedHourlyLevels3.add(null);
expectedHourlyLevels3.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels3.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels3.add(BATTERY_LEVEL_UNKNOWN);
expectedHourlyLevels3.add(88);
final List<List<Integer>> expectedHourlyLevels = List.of(
expectedHourlyLevels1,
@@ -734,141 +727,6 @@ public final class DataProcessorTest {
verifyExpectedTimestampSlots(startTimestamp, endTimestamp, expectedTimestamps);
}
@Test
public void getDailyTimestamps_notEnoughData_returnEmptyList() {
assertThat(DataProcessor.getDailyTimestamps(new ArrayList<>())).isEmpty();
assertThat(DataProcessor.getDailyTimestamps(List.of(100L))).isEmpty();
}
@Test
public void getDailyTimestamps_allDataInOneHour_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640970006000L, // 2022-01-01 01:00:06
1640973608000L // 2022-01-01 01:00:08
);
final List<Long> expectedTimestamps = List.of(
1640970006000L, // 2022-01-01 01:00:06
1640973608000L // 2022-01-01 01:00:08
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_OneHourDataPerDay_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
1641056400000L // 2022-01-02 01:00:00
);
final List<Long> expectedTimestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
1641056400000L // 2022-01-02 01:00:00
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_OneDayData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640966400000L, // 2022-01-01 00:00:00
1640970000000L, // 2022-01-01 01:00:00
1640973600000L, // 2022-01-01 02:00:00
1640977200000L, // 2022-01-01 03:00:00
1640980800000L // 2022-01-01 04:00:00
);
final List<Long> expectedTimestamps = List.of(
1640966400000L, // 2022-01-01 00:00:00
1640980800000L // 2022-01-01 04:00:00
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_MultipleDaysData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1641045600000L, // 2022-01-01 22:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641232800000L // 2022-01-04 02:00:00
);
final List<Long> expectedTimestamps = List.of(
1641045600000L, // 2022-01-01 22:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L, // 2022-01-04 00:00:00
1641232800000L // 2022-01-04 02:00:00
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_FirstDayOneHourData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641254400000L // 2022-01-04 08:00:00
);
final List<Long> expectedTimestamps = List.of(
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L, // 2022-01-04 00:00:00
1641254400000L // 2022-01-04 08:00:00
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_LastDayNoData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641225600000L // 2022-01-04 00:00:00
);
final List<Long> expectedTimestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L // 2022-01-04 00:00:00
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void getDailyTimestamps_LastDayOneHourData_returnExpectedList() {
// Timezone GMT+8
final List<Long> timestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641060000000L, // 2022-01-02 02:00:00
1641160800000L, // 2022-01-03 06:00:00
1641229200000L // 2022-01-04 01:00:00
);
final List<Long> expectedTimestamps = List.of(
1640988000000L, // 2022-01-01 06:00:00
1641052800000L, // 2022-01-02 00:00:00
1641139200000L, // 2022-01-03 00:00:00
1641225600000L, // 2022-01-04 00:00:00
1641229200000L // 2022-01-04 01:00:00
);
assertThat(DataProcessor.getDailyTimestamps(timestamps)).isEqualTo(expectedTimestamps);
}
@Test
public void isFromFullCharge_emptyData_returnFalse() {
assertThat(DataProcessor.isFromFullCharge(null)).isFalse();
@@ -916,20 +774,53 @@ public final class DataProcessorTest {
}
@Test
public void getBatteryUsageMap_emptyHistoryMap_returnNull() {
public void getBatteryDiffDataMap_emptyHistoryMap_returnEmpty() {
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(new ArrayList<>(), new ArrayList<>()));
new BatteryLevelData.PeriodBatteryLevelData(new ArrayMap<>(), new ArrayList<>()));
assertThat(DataProcessor.getBatteryUsageMap(
mContext, hourlyBatteryLevelsPerDay, new HashMap<>(), /*appUsagePeriodMap=*/ null))
.isNull();
assertThat(DataProcessor.getBatteryDiffDataMap(mContext, hourlyBatteryLevelsPerDay,
new HashMap<>(), /*appUsagePeriodMap=*/ null, Set.of(), Set.of())).isEmpty();
}
@Test
public void getBatteryUsageMap_returnsExpectedResult() {
public void getBatteryDiffDataMap_normalFlow_returnExpectedResult() {
final int userId = mContext.getUserId();
final long[] batteryHistoryKeys = new long[]{
1641045600000L, // 2022-01-01 22:00:00
1641049200000L, // 2022-01-01 23:00:00
1641052800000L, // 2022-01-02 00:00:00
};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = Map.of(
batteryHistoryKeys[0], Map.of(FAKE_PACKAGE_NAME, createBatteryHistEntry(
FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0, 0, 0,
0, 0, 0L, userId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, 0L, 0L, false)),
batteryHistoryKeys[1], Map.of(FAKE_PACKAGE_NAME, createBatteryHistEntry(
FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 5, 0, 0,
0, 0, 0L, userId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, 0L, 0L, false)),
batteryHistoryKeys[2], Map.of(FAKE_PACKAGE_NAME, createBatteryHistEntry(
FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 16, 0, 0,
0, 0, 0L, userId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, 0L, 0L, false)));
final BatteryLevelData batteryLevelData = generateBatteryLevelData(batteryHistoryKeys);
final Map<Integer, Map<Integer, Map<Long, Map<String, List<AppUsagePeriod>>>>>
appUsagePeriodMap = Map.of(0, Map.of(0, Map.of(Long.valueOf(userId), Map.of(
FAKE_PACKAGE_NAME, List.of(buildAppUsagePeriod(0, 6))))));
Map<Long, BatteryDiffData> batteryDiffDataMap = DataProcessor.getBatteryDiffDataMap(
mContext, batteryLevelData.getHourlyBatteryLevelsPerDay(), batteryHistoryMap,
appUsagePeriodMap, Set.of(), Set.of());
assertThat(batteryDiffDataMap).hasSize(1);
assertThat(batteryDiffDataMap).containsKey(batteryHistoryKeys[0]);
BatteryDiffData batteryDiffData = batteryDiffDataMap.get(batteryHistoryKeys[0]);
assertThat(batteryDiffData.getStartTimestamp()).isEqualTo(batteryHistoryKeys[0]);
assertThat(batteryDiffData.getEndTimestamp()).isEqualTo(batteryHistoryKeys[2]);
}
@Test
public void generateBatteryUsageMap_returnsExpectedResult() {
final long[] batteryHistoryKeys = new long[]{
1641045600000L, // 2022-01-01 22:00:00
1641049200000L, // 2022-01-01 23:00:00
@@ -940,7 +831,7 @@ public final class DataProcessorTest {
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = new HashMap<>();
final int currentUserId = mContext.getUserId();
final BatteryHistEntry fakeEntry = createBatteryHistEntry(
ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0,
FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 0L, currentUserId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
@@ -1030,19 +921,7 @@ public final class DataProcessorTest {
entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(batteryHistoryKeys[4], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
// Adds the day 1 data.
List<Long> timestamps =
List.of(batteryHistoryKeys[0], batteryHistoryKeys[2]);
final List<Integer> levels = List.of(100, 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps, levels));
// Adds the day 2 data.
timestamps = List.of(batteryHistoryKeys[2], batteryHistoryKeys[4]);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps, levels));
final BatteryLevelData batteryLevelData = generateBatteryLevelData(batteryHistoryKeys);
// Adds app usage data to test screen on time.
final Map<Integer, Map<Integer, Map<Long, Map<String, List<AppUsagePeriod>>>>>
appUsagePeriodMap = new HashMap<>();
@@ -1066,8 +945,12 @@ public final class DataProcessorTest {
appUsagePeriodMap.get(1).put(0, appUsageMap);
final Map<Integer, Map<Integer, BatteryDiffData>> resultMap =
DataProcessor.getBatteryUsageMap(
mContext, hourlyBatteryLevelsPerDay, batteryHistoryMap, appUsagePeriodMap);
DataProcessor.generateBatteryUsageMap(
mContext,
DataProcessor.getBatteryDiffDataMap(mContext,
batteryLevelData.getHourlyBatteryLevelsPerDay(), batteryHistoryMap,
appUsagePeriodMap, Set.of(), Set.of()),
batteryLevelData);
BatteryDiffData resultDiffData =
resultMap
@@ -1128,7 +1011,7 @@ public final class DataProcessorTest {
}
@Test
public void getBatteryUsageMap_multipleUsers_returnsExpectedResult() {
public void generateBatteryUsageMap_multipleUsers_returnsExpectedResult() {
final long[] batteryHistoryKeys = new long[]{
1641052800000L, // 2022-01-02 00:00:00
1641056400000L, // 2022-01-02 01:00:00
@@ -1217,17 +1100,15 @@ public final class DataProcessorTest {
/*backgroundUsageTimeInMs=*/ 30L, /*isHidden=*/ false);
entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
List<Long> timestamps = List.of(batteryHistoryKeys[0], batteryHistoryKeys[2]);
final List<Integer> levels = List.of(100, 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps, levels));
final BatteryLevelData batteryLevelData = generateBatteryLevelData(batteryHistoryKeys);
final Map<Integer, Map<Integer, BatteryDiffData>> resultMap =
DataProcessor.getBatteryUsageMap(
mContext, hourlyBatteryLevelsPerDay, batteryHistoryMap,
/*appUsagePeriodMap=*/ null);
DataProcessor.generateBatteryUsageMap(
mContext,
DataProcessor.getBatteryDiffDataMap(mContext,
batteryLevelData.getHourlyBatteryLevelsPerDay(), batteryHistoryMap,
/*appUsagePeriodMap=*/ null, Set.of(), Set.of()),
batteryLevelData);
final BatteryDiffData resultDiffData =
resultMap
@@ -1247,7 +1128,7 @@ public final class DataProcessorTest {
}
@Test
public void getBatteryUsageMap_usageTimeExceed_returnsExpectedResult() {
public void generateBatteryUsageMap_usageTimeExceed_returnsExpectedResult() {
final long[] batteryHistoryKeys = new long[]{
1641052800000L, // 2022-01-02 00:00:00
1641056400000L, // 2022-01-02 01:00:00
@@ -1288,12 +1169,7 @@ public final class DataProcessorTest {
/*backgroundUsageTimeInMs=*/ 7200000L, /*isHidden=*/ false);
entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
List<Long> timestamps = List.of(batteryHistoryKeys[0], batteryHistoryKeys[2]);
final List<Integer> levels = List.of(100, 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps, levels));
final BatteryLevelData batteryLevelData = generateBatteryLevelData(batteryHistoryKeys);
// Adds app usage data to test screen on time.
final Map<Integer, Map<Integer, Map<Long, Map<String, List<AppUsagePeriod>>>>>
@@ -1307,8 +1183,12 @@ public final class DataProcessorTest {
appUsagePeriodMap.get(0).put(0, appUsageMap);
final Map<Integer, Map<Integer, BatteryDiffData>> resultMap =
DataProcessor.getBatteryUsageMap(
mContext, hourlyBatteryLevelsPerDay, batteryHistoryMap, appUsagePeriodMap);
DataProcessor.generateBatteryUsageMap(
mContext,
DataProcessor.getBatteryDiffDataMap(mContext,
batteryLevelData.getHourlyBatteryLevelsPerDay(), batteryHistoryMap,
appUsagePeriodMap, Set.of(), Set.of()),
batteryLevelData);
final BatteryDiffData resultDiffData =
resultMap
@@ -1338,7 +1218,7 @@ public final class DataProcessorTest {
}
@Test
public void getBatteryUsageMap_hideApplicationEntries_returnsExpectedResult() {
public void generateBatteryUsageMap_hideApplicationEntries_returnsExpectedResult() {
final long[] batteryHistoryKeys = new long[]{
1641052800000L, // 2022-01-02 00:00:00
1641056400000L, // 2022-01-02 01:00:00
@@ -1403,19 +1283,17 @@ public final class DataProcessorTest {
/*backgroundUsageTimeInMs=*/ 20L, /*isHidden=*/ false);
entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
List<Long> timestamps = List.of(batteryHistoryKeys[0], batteryHistoryKeys[2]);
final List<Integer> levels = List.of(100, 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps, levels));
final BatteryLevelData batteryLevelData = generateBatteryLevelData(batteryHistoryKeys);
when(mPowerUsageFeatureProvider.getHideApplicationSet())
.thenReturn(Set.of("package1"));
final Map<Integer, Map<Integer, BatteryDiffData>> resultMap =
DataProcessor.getBatteryUsageMap(
mContext, hourlyBatteryLevelsPerDay, batteryHistoryMap,
/*appUsagePeriodMap=*/ null);
DataProcessor.generateBatteryUsageMap(
mContext,
DataProcessor.getBatteryDiffDataMap(mContext,
batteryLevelData.getHourlyBatteryLevelsPerDay(), batteryHistoryMap,
/*appUsagePeriodMap=*/ null, Set.of(), Set.of()),
batteryLevelData);
final BatteryDiffData resultDiffData =
resultMap
@@ -1431,7 +1309,7 @@ public final class DataProcessorTest {
}
@Test
public void getBatteryUsageMap_hideBackgroundUsageTime_returnsExpectedResult() {
public void generateBatteryUsageMap_hideBackgroundUsageTime_returnsExpectedResult() {
final long[] batteryHistoryKeys = new long[]{
1641052800000L, // 2022-01-02 00:00:00
1641056400000L, // 2022-01-02 01:00:00
@@ -1496,19 +1374,17 @@ public final class DataProcessorTest {
/*backgroundUsageTimeInMs=*/ 20L, /*isHidden=*/ false);
entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
new ArrayList<>();
List<Long> timestamps = List.of(batteryHistoryKeys[0], batteryHistoryKeys[2]);
final List<Integer> levels = List.of(100, 100);
hourlyBatteryLevelsPerDay.add(
new BatteryLevelData.PeriodBatteryLevelData(timestamps, levels));
final BatteryLevelData batteryLevelData = generateBatteryLevelData(batteryHistoryKeys);
when(mPowerUsageFeatureProvider.getHideBackgroundUsageTimeSet())
.thenReturn(new HashSet(Arrays.asList((CharSequence) "package2")));
final Map<Integer, Map<Integer, BatteryDiffData>> resultMap =
DataProcessor.getBatteryUsageMap(
mContext, hourlyBatteryLevelsPerDay, batteryHistoryMap,
/*appUsagePeriodMap=*/ null);
DataProcessor.generateBatteryUsageMap(
mContext,
DataProcessor.getBatteryDiffDataMap(mContext,
batteryLevelData.getHourlyBatteryLevelsPerDay(), batteryHistoryMap,
/*appUsagePeriodMap=*/ null, Set.of(), Set.of()),
batteryLevelData);
final BatteryDiffData resultDiffData =
resultMap
@@ -1523,7 +1399,10 @@ public final class DataProcessorTest {
@Test
public void generateBatteryDiffData_emptyBatteryEntryList_returnNull() {
assertThat(DataProcessor.generateBatteryDiffData(mContext,
DataProcessor.convertToBatteryHistEntry(null, mBatteryUsageStats))).isNull();
System.currentTimeMillis(),
DataProcessor.convertToBatteryHistEntry(null, mBatteryUsageStats),
/* systemAppsPackageNames= */ Set.of(),
/* systemAppsUids= */ Set.of())).isNull();
}
@Test
@@ -1574,7 +1453,10 @@ public final class DataProcessorTest {
.when(mMockBatteryEntry4).getPowerComponentId();
final BatteryDiffData batteryDiffData = DataProcessor.generateBatteryDiffData(mContext,
DataProcessor.convertToBatteryHistEntry(batteryEntryList, mBatteryUsageStats));
System.currentTimeMillis(),
DataProcessor.convertToBatteryHistEntry(batteryEntryList, mBatteryUsageStats),
/* systemAppsPackageNames= */ Set.of(),
/* systemAppsUids= */ Set.of());
assertBatteryDiffEntry(
batteryDiffData.getAppDiffEntryList().get(0), 0, /*uid=*/ 2L,
@@ -2041,9 +1923,9 @@ public final class DataProcessorTest {
final double backgroundUsageConsumePower, final double cachedUsageConsumePower,
final long foregroundUsageTimeInMs, final long backgroundUsageTimeInMs,
final long screenOnTimeInMs) {
assertThat(entry.mBatteryHistEntry.mUserId).isEqualTo(userId);
assertThat(entry.mBatteryHistEntry.mUid).isEqualTo(uid);
assertThat(entry.mBatteryHistEntry.mConsumerType).isEqualTo(consumerType);
assertThat(entry.mUserId).isEqualTo(userId);
assertThat(entry.mUid).isEqualTo(uid);
assertThat(entry.mConsumerType).isEqualTo(consumerType);
assertThat(entry.getPercentage()).isEqualTo(consumePercentage);
assertThat(entry.mForegroundUsageConsumePower).isEqualTo(foregroundUsageConsumePower);
assertThat(entry.mForegroundServiceUsageConsumePower)
@@ -2054,4 +1936,12 @@ public final class DataProcessorTest {
assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs);
assertThat(entry.mScreenOnTimeInMs).isEqualTo(screenOnTimeInMs);
}
private BatteryLevelData generateBatteryLevelData(long[] timestamps) {
Map<Long, Integer> batteryLevelMap = new ArrayMap<>();
for (long timestamp : timestamps) {
batteryLevelMap.put(timestamp, 100);
}
return new BatteryLevelData(batteryLevelMap);
}
}

43
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtilsTest.java
View File

@@ -173,8 +173,8 @@ public final class DatabaseUtilsTest {
doReturn(null).when(mContext).registerReceiver(any(), any());
assertThat(
DatabaseUtils.sendBatteryEntryData(
mContext, /*batteryEntryList=*/ null, mBatteryUsageStats,
/*isFullChargeStart=*/ false))
mContext, System.currentTimeMillis(), /*batteryEntryList=*/ null,
mBatteryUsageStats, /*isFullChargeStart=*/ false))
.isNull();
}
@@ -193,7 +193,10 @@ public final class DatabaseUtilsTest {
final List<ContentValues> valuesList =
DatabaseUtils.sendBatteryEntryData(
mContext, batteryEntryList, mBatteryUsageStats,
mContext,
System.currentTimeMillis(),
batteryEntryList,
mBatteryUsageStats,
/*isFullChargeStart=*/ false);
assertThat(valuesList).hasSize(2);
@@ -216,6 +219,7 @@ public final class DatabaseUtilsTest {
final List<ContentValues> valuesList =
DatabaseUtils.sendBatteryEntryData(
mContext,
System.currentTimeMillis(),
new ArrayList<>(),
mBatteryUsageStats,
/*isFullChargeStart=*/ false);
@@ -235,6 +239,7 @@ public final class DatabaseUtilsTest {
final List<ContentValues> valuesList =
DatabaseUtils.sendBatteryEntryData(
mContext,
System.currentTimeMillis(),
/*batteryEntryList=*/ null,
mBatteryUsageStats,
/*isFullChargeStart=*/ false);
@@ -254,6 +259,7 @@ public final class DatabaseUtilsTest {
final List<ContentValues> valuesList =
DatabaseUtils.sendBatteryEntryData(
mContext,
System.currentTimeMillis(),
/*batteryEntryList=*/ null,
/*batteryUsageStats=*/ null,
/*isFullChargeStart=*/ false);
@@ -359,7 +365,7 @@ public final class DatabaseUtilsTest {
}
@Test
public void getHistoryMapSinceLastFullCharge_emptyCursorContent_returnEmptyMap() {
public void getHistoryMap_emptyCursorContent_returnEmptyMap() {
final MatrixCursor cursor = new MatrixCursor(
new String[] {
BatteryHistEntry.KEY_UID,
@@ -367,36 +373,33 @@ public final class DatabaseUtilsTest {
BatteryHistEntry.KEY_TIMESTAMP});
DatabaseUtils.sFakeSupplier = () -> cursor;
assertThat(DatabaseUtils.getHistoryMapSinceLastFullCharge(
mContext, /*calendar=*/ null)).isEmpty();
assertThat(DatabaseUtils.getHistoryMapSinceQueryTimestamp(mContext, 0)).isEmpty();
}
@Test
public void getHistoryMapSinceLastFullCharge_nullCursor_returnEmptyMap() {
public void getHistoryMap_nullCursor_returnEmptyMap() {
DatabaseUtils.sFakeSupplier = () -> null;
assertThat(DatabaseUtils.getHistoryMapSinceLastFullCharge(
mContext, /*calendar=*/ null)).isEmpty();
assertThat(DatabaseUtils.getHistoryMapSinceQueryTimestamp(mContext, 0)).isEmpty();
}
@Test
public void getHistoryMapSinceLastFullCharge_returnExpectedMap() {
public void getHistoryMap_returnExpectedMap() {
final Long timestamp1 = Long.valueOf(1001L);
final Long timestamp2 = Long.valueOf(1002L);
final MatrixCursor cursor = getMatrixCursor();
// Adds fake data into the cursor.
cursor.addRow(new Object[] {
"app name1", timestamp1, 1, ConvertUtils.CONSUMER_TYPE_UID_BATTERY});
"app name1", timestamp1, 1, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, true});
cursor.addRow(new Object[] {
"app name2", timestamp2, 2, ConvertUtils.CONSUMER_TYPE_UID_BATTERY});
"app name2", timestamp2, 2, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false});
cursor.addRow(new Object[] {
"app name3", timestamp2, 3, ConvertUtils.CONSUMER_TYPE_UID_BATTERY});
"app name3", timestamp2, 3, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false});
cursor.addRow(new Object[] {
"app name4", timestamp2, 4, ConvertUtils.CONSUMER_TYPE_UID_BATTERY});
"app name4", timestamp2, 4, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, false});
DatabaseUtils.sFakeSupplier = () -> cursor;
final Map<Long, Map<String, BatteryHistEntry>> batteryHistMap =
DatabaseUtils.getHistoryMapSinceLastFullCharge(
mContext, /*calendar=*/ null);
DatabaseUtils.getHistoryMapSinceQueryTimestamp(mContext, timestamp1);
assertThat(batteryHistMap).hasSize(2);
// Verifies the BatteryHistEntry data for timestamp1.
@@ -412,7 +415,7 @@ public final class DatabaseUtilsTest {
}
@Test
public void getHistoryMapSinceLastFullCharge_withWorkProfile_returnExpectedMap()
public void getHistoryMap_withWorkProfile_returnExpectedMap()
throws PackageManager.NameNotFoundException {
doReturn("com.fake.package").when(mContext).getPackageName();
doReturn(mMockContext).when(mContext).createPackageContextAsUser(
@@ -425,8 +428,7 @@ public final class DatabaseUtilsTest {
DatabaseUtils.sFakeSupplier = () -> getMatrixCursor();
final Map<Long, Map<String, BatteryHistEntry>> batteryHistMap =
DatabaseUtils.getHistoryMapSinceLastFullCharge(
mContext, /*calendar=*/ null);
DatabaseUtils.getHistoryMapSinceQueryTimestamp(mContext, 0);
assertThat(batteryHistMap).isEmpty();
}
@@ -571,6 +573,7 @@ public final class DatabaseUtilsTest {
BatteryHistEntry.KEY_PACKAGE_NAME,
BatteryHistEntry.KEY_TIMESTAMP,
BatteryHistEntry.KEY_UID,
BatteryHistEntry.KEY_CONSUMER_TYPE});
BatteryHistEntry.KEY_CONSUMER_TYPE,
BatteryHistEntry.KEY_IS_FULL_CHARGE_CYCLE_START});
}
}

5
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/PowerUsageBaseTest.java
View File

@@ -134,11 +134,6 @@ public class PowerUsageBaseTest {
return 0;
}
@Override
protected boolean isBatteryHistoryNeeded() {
return false;
}
@Override
protected void refreshUi(int refreshType) {
// Do nothing

82
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryEventDaoTest.java
View File

@@ -16,6 +16,10 @@
package com.android.settings.fuelgauge.batteryusage.db;
import static com.android.settings.fuelgauge.batteryusage.db.BatteryEventEntity.KEY_BATTERY_EVENT_TYPE;
import static com.android.settings.fuelgauge.batteryusage.db.BatteryEventEntity.KEY_BATTERY_LEVEL;
import static com.android.settings.fuelgauge.batteryusage.db.BatteryEventEntity.KEY_TIMESTAMP;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
@@ -31,9 +35,14 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import java.util.List;
/** Tests for {@link BatteryEventDao}. */
@RunWith(RobolectricTestRunner.class)
public final class BatteryEventDaoTest {
private static final long TIMESTAMP1 = System.currentTimeMillis();
private static final long TIMESTAMP2 = TIMESTAMP1 + 2;
private Context mContext;
private BatteryStateDatabase mDatabase;
private BatteryEventDao mBatteryEventDao;
@@ -51,8 +60,44 @@ public final class BatteryEventDaoTest {
BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
}
@Test
public void getAllAfter_returnExpectedResult() {
public void getLastFullChargeTimestamp_normalFlow_expectedBehavior() throws Exception {
mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
.setTimestamp(TIMESTAMP1)
.setBatteryEventType(3)
.setBatteryLevel(100)
.build());
mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
.setTimestamp(TIMESTAMP2)
.setBatteryEventType(4)
.setBatteryLevel(96)
.build());
final Cursor cursor = mBatteryEventDao.getLastFullChargeTimestamp();
assertThat(cursor.getCount()).isEqualTo(1);
cursor.moveToFirst();
assertThat(cursor.getLong(0)).isEqualTo(TIMESTAMP1);
}
@Test
public void getLastFullChargeTimestamp_noLastFullChargeTime_returns0() throws Exception {
mBatteryEventDao.clearAll();
mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
.setTimestamp(TIMESTAMP2)
.setBatteryEventType(4)
.setBatteryLevel(96)
.build());
final Cursor cursor = mBatteryEventDao.getLastFullChargeTimestamp();
assertThat(cursor.getCount()).isEqualTo(1);
cursor.moveToFirst();
assertThat(cursor.getLong(0)).isEqualTo(0L);
}
@Test
public void getAllAfter_normalFlow_returnExpectedResult() {
mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
.setTimestamp(100L)
.setBatteryEventType(1)
@@ -64,17 +109,44 @@ public final class BatteryEventDaoTest {
.setBatteryLevel(88)
.build());
final Cursor cursor = mBatteryEventDao.getAllAfter(160L);
final Cursor cursor = mBatteryEventDao.getAllAfter(160L, List.of(1, 2));
assertThat(cursor.getCount()).isEqualTo(1);
cursor.moveToFirst();
assertThat(cursor.getLong(cursor.getColumnIndex(BatteryEventEntity.KEY_TIMESTAMP)))
assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP)))
.isEqualTo(200L);
assertThat(cursor.getInt(cursor.getColumnIndex(BatteryEventEntity.KEY_BATTERY_EVENT_TYPE)))
assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE)))
.isEqualTo(2);
assertThat(cursor.getInt(cursor.getColumnIndex(BatteryEventEntity.KEY_BATTERY_LEVEL)))
assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL)))
.isEqualTo(88);
mBatteryEventDao.clearAll();
assertThat(mBatteryEventDao.getAll()).isEmpty();
}
@Test
public void getAllAfter_filterBatteryTypes_returnExpectedResult() {
mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
.setTimestamp(100L)
.setBatteryEventType(1)
.setBatteryLevel(66)
.build());
mBatteryEventDao.insert(BatteryEventEntity.newBuilder()
.setTimestamp(200L)
.setBatteryEventType(2)
.setBatteryLevel(88)
.build());
final Cursor cursor = mBatteryEventDao.getAllAfter(0L, List.of(1));
assertThat(cursor.getCount()).isEqualTo(1);
cursor.moveToFirst();
assertThat(cursor.getLong(cursor.getColumnIndex(KEY_TIMESTAMP)))
.isEqualTo(100L);
assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_EVENT_TYPE)))
.isEqualTo(1);
assertThat(cursor.getInt(cursor.getColumnIndex(KEY_BATTERY_LEVEL)))
.isEqualTo(66);
mBatteryEventDao.clearAll();
assertThat(mBatteryEventDao.getAll()).isEmpty();
}
}

61
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateDaoTest.java
View File

@@ -37,9 +37,10 @@ import java.util.List;
@RunWith(RobolectricTestRunner.class)
public final class BatteryStateDaoTest {
private static final int CURSOR_COLUMN_SIZE = 9;
private static final long TIMESTAMP1 = System.currentTimeMillis();
private static final long TIMESTAMP2 = System.currentTimeMillis() + 2;
private static final long TIMESTAMP3 = System.currentTimeMillis() + 4;
private static final long CURRENT = System.currentTimeMillis();
private static final long TIMESTAMP1 = CURRENT;
private static final long TIMESTAMP2 = CURRENT + 2;
private static final long TIMESTAMP3 = CURRENT + 4;
private static final String PACKAGE_NAME1 = "com.android.apps.settings";
private static final String PACKAGE_NAME2 = "com.android.apps.calendar";
private static final String PACKAGE_NAME3 = "com.android.apps.gmail";
@@ -67,7 +68,7 @@ public final class BatteryStateDaoTest {
}
@Test
public void batteryStateDao_insertAll() throws Exception {
public void insertAll_normalFlow_expectedBehavior() throws Exception {
final List<BatteryState> states = mBatteryStateDao.getAllAfter(TIMESTAMP1);
assertThat(states).hasSize(2);
// Verifies the queried battery states.
@@ -76,8 +77,26 @@ public final class BatteryStateDaoTest {
}
@Test
public void batteryStateDao_getCursorSinceLastFullCharge() throws Exception {
final Cursor cursor1 = mBatteryStateDao.getCursorSinceLastFullCharge(TIMESTAMP1);
public void getLatestTimestamp_normalFlow_expectedBehavior() throws Exception {
final Cursor cursor1 = mBatteryStateDao.getLatestTimestampBefore(TIMESTAMP1 - 1);
assertThat(cursor1.getCount()).isEqualTo(1);
cursor1.moveToFirst();
assertThat(cursor1.getLong(0)).isEqualTo(0L);
final Cursor cursor2 = mBatteryStateDao.getLatestTimestampBefore(TIMESTAMP2);
assertThat(cursor2.getCount()).isEqualTo(1);
cursor2.moveToFirst();
assertThat(cursor2.getLong(0)).isEqualTo(TIMESTAMP2);
final Cursor cursor3 = mBatteryStateDao.getLatestTimestampBefore(TIMESTAMP3 + 1);
assertThat(cursor3.getCount()).isEqualTo(1);
cursor3.moveToFirst();
assertThat(cursor3.getLong(0)).isEqualTo(TIMESTAMP3);
}
@Test
public void getBatteryStatesAfter_normalFlow_expectedBehavior() throws Exception {
final Cursor cursor1 = mBatteryStateDao.getBatteryStatesAfter(TIMESTAMP1);
assertThat(cursor1.getCount()).isEqualTo(3);
assertThat(cursor1.getColumnCount()).isEqualTo(CURSOR_COLUMN_SIZE);
// Verifies the queried first battery state.
@@ -90,7 +109,7 @@ public final class BatteryStateDaoTest {
cursor1.moveToNext();
assertThat(cursor1.getString(3 /*packageName*/)).isEqualTo(PACKAGE_NAME3);
final Cursor cursor2 = mBatteryStateDao.getCursorSinceLastFullCharge(TIMESTAMP3);
final Cursor cursor2 = mBatteryStateDao.getBatteryStatesAfter(TIMESTAMP3);
assertThat(cursor2.getCount()).isEqualTo(1);
assertThat(cursor2.getColumnCount()).isEqualTo(CURSOR_COLUMN_SIZE);
// Verifies the queried first battery state.
@@ -99,25 +118,7 @@ public final class BatteryStateDaoTest {
}
@Test
public void batteryStateDao_getCursorSinceLastFullCharge_noFullChargeData_returnSevenDaysData()
throws Exception {
mBatteryStateDao.clearAll();
BatteryTestUtils.insertDataToBatteryStateTable(mContext, TIMESTAMP3, PACKAGE_NAME3);
BatteryTestUtils.insertDataToBatteryStateTable(mContext, TIMESTAMP2, PACKAGE_NAME2);
BatteryTestUtils.insertDataToBatteryStateTable(mContext, TIMESTAMP1, PACKAGE_NAME1);
final Cursor cursor = mBatteryStateDao.getCursorSinceLastFullCharge(TIMESTAMP2);
assertThat(cursor.getCount()).isEqualTo(2);
assertThat(cursor.getColumnCount()).isEqualTo(CURSOR_COLUMN_SIZE);
// Verifies the queried first battery state.
cursor.moveToFirst();
assertThat(cursor.getString(3 /*packageName*/)).isEqualTo(PACKAGE_NAME2);
// Verifies the queried third battery state.
cursor.moveToNext();
assertThat(cursor.getString(3 /*packageName*/)).isEqualTo(PACKAGE_NAME3);
}
@Test
public void batteryStateDao_clearAllBefore() throws Exception {
public void clearAllBefore_normalFlow_expectedBehavior() throws Exception {
mBatteryStateDao.clearAllBefore(TIMESTAMP2);
final List<BatteryState> states = mBatteryStateDao.getAllAfter(0);
@@ -127,20 +128,20 @@ public final class BatteryStateDaoTest {
}
@Test
public void batteryStateDao_clearAll() throws Exception {
public void clearAll_normalFlow_expectedBehavior() throws Exception {
assertThat(mBatteryStateDao.getAllAfter(0)).hasSize(3);
mBatteryStateDao.clearAll();
assertThat(mBatteryStateDao.getAllAfter(0)).isEmpty();
}
@Test
public void getInstance_createNewInstance() throws Exception {
public void getInstance_createNewInstance_returnsExpectedResult() throws Exception {
BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
assertThat(BatteryStateDatabase.getInstance(mContext)).isNotNull();
}
@Test
public void getDistinctTimestampCount_returnsExpectedResult() {
public void getDistinctTimestampCount_normalFlow_returnsExpectedResult() {
assertThat(mBatteryStateDao.getDistinctTimestampCount(/*timestamp=*/ 0))
.isEqualTo(3);
assertThat(mBatteryStateDao.getDistinctTimestampCount(TIMESTAMP1))
@@ -148,7 +149,7 @@ public final class BatteryStateDaoTest {
}
@Test
public void getDistinctTimestamps_returnsExpectedResult() {
public void getDistinctTimestamps_normalFlow_returnsExpectedResult() {
final List<Long> timestamps =
mBatteryStateDao.getDistinctTimestamps(/*timestamp=*/ 0);

110
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryUsageSlotDaoTest.java Normal file
View File

@@ -0,0 +1,110 @@
/*
* Copyright (C) 2022 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.batteryusage.db;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
import android.database.Cursor;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.testutils.BatteryTestUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import java.util.List;
/** Tests for {@link BatteryUsageSlotDao}. */
@RunWith(RobolectricTestRunner.class)
public final class BatteryUsageSlotDaoTest {
private static final int CURSOR_COLUMN_SIZE = 3;
private static final long CURRENT = System.currentTimeMillis();
private static final long TIMESTAMP1 = CURRENT;
private static final long TIMESTAMP2 = CURRENT + 2;
private static final String BATTERY_USAGE_SLOT_STRING1 = "BATTERY_USAGE_SLOT_STRING1";
private static final String BATTERY_USAGE_SLOT_STRING2 = "BATTERY_USAGE_SLOT_STRING2";
private Context mContext;
private BatteryStateDatabase mDatabase;
private BatteryUsageSlotDao mBatteryUsageSlotDao;
@Before
public void setUp() {
mContext = ApplicationProvider.getApplicationContext();
mDatabase = BatteryTestUtils.setUpBatteryStateDatabase(mContext);
mBatteryUsageSlotDao = mDatabase.batteryUsageSlotDao();
mBatteryUsageSlotDao.insert(
new BatteryUsageSlotEntity(TIMESTAMP1, BATTERY_USAGE_SLOT_STRING1));
mBatteryUsageSlotDao.insert(
new BatteryUsageSlotEntity(TIMESTAMP2, BATTERY_USAGE_SLOT_STRING2));
}
@After
public void closeDb() {
mDatabase.close();
BatteryStateDatabase.setBatteryStateDatabase(/*database=*/ null);
}
@Test
public void getAll_normalFlow_expectedBehavior() throws Exception {
final List<BatteryUsageSlotEntity> entities = mBatteryUsageSlotDao.getAll();
assertThat(entities).hasSize(2);
assertThat(entities.get(0).timestamp).isEqualTo(TIMESTAMP1);
assertThat(entities.get(0).batteryUsageSlot).isEqualTo(BATTERY_USAGE_SLOT_STRING1);
assertThat(entities.get(1).timestamp).isEqualTo(TIMESTAMP2);
assertThat(entities.get(1).batteryUsageSlot).isEqualTo(BATTERY_USAGE_SLOT_STRING2);
}
@Test
public void getAllAfter_normalFlow_expectedBehavior() throws Exception {
final Cursor cursor1 = mBatteryUsageSlotDao.getAllAfter(TIMESTAMP1);
assertThat(cursor1.getCount()).isEqualTo(2);
assertThat(cursor1.getColumnCount()).isEqualTo(CURSOR_COLUMN_SIZE);
cursor1.moveToFirst();
assertThat(cursor1.getLong(1 /*timestamp*/)).isEqualTo(TIMESTAMP1);
cursor1.moveToNext();
assertThat(cursor1.getLong(1 /*timestamp*/)).isEqualTo(TIMESTAMP2);
final Cursor cursor2 = mBatteryUsageSlotDao.getAllAfter(TIMESTAMP1 + 1);
assertThat(cursor2.getCount()).isEqualTo(1);
assertThat(cursor2.getColumnCount()).isEqualTo(CURSOR_COLUMN_SIZE);
cursor2.moveToFirst();
assertThat(cursor2.getLong(1 /*timestamp*/)).isEqualTo(TIMESTAMP2);
}
@Test
public void clearAllBefore_normalFlow_expectedBehavior() throws Exception {
mBatteryUsageSlotDao.clearAllBefore(TIMESTAMP1);
final List<BatteryUsageSlotEntity> entities = mBatteryUsageSlotDao.getAll();
assertThat(entities).hasSize(1);
assertThat(entities.get(0).timestamp).isEqualTo(TIMESTAMP2);
assertThat(entities.get(0).batteryUsageSlot).isEqualTo(BATTERY_USAGE_SLOT_STRING2);
}
@Test
public void clearAll_normalFlow_expectedBehavior() throws Exception {
mBatteryUsageSlotDao.clearAll();
assertThat(mBatteryUsageSlotDao.getAll()).isEmpty();
}
}

44
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryUsageSlotEntityTest.java Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright (C) 2023 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.batteryusage.db;
import static com.google.common.truth.Truth.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
/** Tests for {@link BatteryUsageSlotEntity}. */
@RunWith(RobolectricTestRunner.class)
public final class BatteryUsageSlotEntityTest {
@Test
public void testBuilder_returnsExpectedResult() {
final long timestamp = 10001L;
final String batteryUsageSlotString = "batteryUsageSlotString";
BatteryUsageSlotEntity entity = BatteryUsageSlotEntity
.newBuilder()
.setTimestamp(timestamp)
.setBatteryUsageSlot(batteryUsageSlotString)
.build();
// Verifies the app relative information.
assertThat(entity.timestamp).isEqualTo(timestamp);
assertThat(entity.batteryUsageSlot).isEqualTo(batteryUsageSlotString);
}
}