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

Merge "Fix broken RoboTests in "com.android.settings.fuelgauge.*"" into main

Browse Source
This commit is contained in:
YK Hung
2023-10-13 10:04:25 +00:00
committed by Android (Google) Code Review
parent a1243188ce a8fa5aad69
commit 261db5468f
2 changed files with 252 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files

409
tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
View File

@@ -30,7 +30,6 @@ import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import static org.robolectric.shadows.ShadowLooper.shadowMainLooper;
import android.app.AppOpsManager;
import android.app.backup.BackupManager;
@@ -42,7 +41,6 @@ import android.content.pm.InstallSourceInfo;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Process;
import android.os.UserHandle;
import androidx.fragment.app.FragmentActivity;
@@ -77,6 +75,8 @@ import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
import java.util.concurrent.TimeUnit;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = {
ShadowEntityHeaderController.class,
@@ -88,7 +88,6 @@ public class AdvancedPowerUsageDetailTest {
private static final String SUMMARY = "summary";
private static final String[] PACKAGE_NAME = {"com.android.app"};
private static final String USAGE_PERCENT = "16%";
private static final String SLOT_TIME = "12 am-2 am";
private static final int ICON_ID = 123;
private static final int UID = 1;
private static final long BACKGROUND_TIME_MS = 100;
@@ -96,7 +95,6 @@ public class AdvancedPowerUsageDetailTest {
private static final long FOREGROUND_SERVICE_TIME_MS = 444;
private static final long FOREGROUND_TIME_MS =
FOREGROUND_ACTIVITY_TIME_MS + FOREGROUND_SERVICE_TIME_MS;
private static final long FOREGROUND_SERVICE_TIME_US = FOREGROUND_SERVICE_TIME_MS * 1000;
private static final String KEY_PREF_UNRESTRICTED = "unrestricted_pref";
private static final String KEY_PREF_OPTIMIZED = "optimized_pref";
private static final String KEY_PREF_RESTRICTED = "restricted_pref";
@@ -263,405 +261,6 @@ public class AdvancedPowerUsageDetailTest {
verify(mEntityHeaderController).setIsInstantApp(true);
}
@Test
public void initHeader_noAnyTimeNoConsumedPower_hasEmptySummary() {
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, /* value */ 0);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEmpty();
}
@Test
public void initHeader_noAnyTimeButConsumedPower_hasEmptySummary() {
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, /* value */ 0);
bundle.putInt(AdvancedPowerUsageDetail.EXTRA_POWER_USAGE_AMOUNT, /* value */ 10);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEmpty();
}
@Test
public void initHeader_ScreenTimeZerobackgroundTwoMin_hasCorrectSummary() {
final long backgroundTimeTwoMinutes = 120000;
final long foregroundTimeZero = 0;
final long screenOnTimeZero = 0;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeZero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeZero);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString())
.isEqualTo("Background: 2 min\n(since last full charge)");
}
@Test
public void initHeader_ScreenTimeZerobackgroundLessThanAMin_hasCorrectSummary() {
final long backgroundTimeLessThanAMinute = 59999;
final long foregroundTimeZero = 0;
final long screenOnTimeZero = 0;
Bundle bundle = new Bundle();
bundle.putLong(
AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanAMinute);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeZero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeZero);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString())
.isEqualTo("Background: less than a min\n(since last full charge)");
}
@Test
public void initHeader_ScreenTimeAMinuteBackgroundTwoMin_hasCorrectSummary() {
final long backgroundTimeTwoMinutes = 120000;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeAMinute);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: 1 min\nBackground: 2 min\n(since last full charge)");
}
@Test
public void initHeader_ScreenTimeAMinuteBackgroundLessThanAMin_hasCorrectSummary() {
final long backgroundTimeLessThanAMinute = 59999;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
Bundle bundle = new Bundle();
bundle.putLong(
AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanAMinute);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeAMinute);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: 1 min\nBackground: less than a min\n(since last full charge)");
}
@Test
public void initHeader_ScreenTimeAMinuteBackgroundZero_hasCorrectSummary() {
final long backgroundTimezero = 0;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimezero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeAMinute);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: 1 min\n(since last full charge)");
}
@Test
public void initHeader_ScreenTimeLessThanAMinBackgroundTwoMin_hasCorrectSummary() {
final long backgroundTimeTwoMinutes = 120000;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeLessThanAMinute = 59999;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeLessThanAMinute);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: less than a min\nBackground: 2 min\n(since last full charge)");
}
@Test
public void initHeader_ScreenTimeLessThanAMinBackgroundLessThanAMin_hasCorrectSummary() {
final long backgroundTimeLessThanAMinute = 59999;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeLessThanAMinute = 59999;
Bundle bundle = new Bundle();
bundle.putLong(
AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanAMinute);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeLessThanAMinute);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: less than a min\nBackground: less than a min\n(since last full "
+ "charge)");
}
@Test
public void initHeader_ScreenTimeLessThanAMinBackgroundZero_hasCorrectSummary() {
final long backgroundTimezero = 0;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeLessThanAMinute = 59999;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimezero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeLessThanAMinute);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: less than a min\n(since last full charge)");
}
@Test
public void initHeader_noAnyTimeNoConsumedPowerWithSlotTime_hasEmptySummary() {
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, /* value */ 0);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEmpty();
}
@Test
public void initHeader_noAnyTimeButConsumedPowerWithSlotTime_hasEmptySummary() {
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, /* value */ 0);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, /* value */ 0);
bundle.putInt(AdvancedPowerUsageDetail.EXTRA_POWER_USAGE_AMOUNT, /* value */ 10);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEmpty();
}
@Test
public void initHeader_ScreenTimeZerobackgroundTwoMinWithSlotTime_hasCorrectSummary() {
final long backgroundTimeTwoMinutes = 120000;
final long foregroundTimeZero = 0;
final long screenOnTimeZero = 0;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeZero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeZero);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString())
.isEqualTo("Background: 2 min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeZerobackgroundLessThanAMinWithSlotTime_hasCorrectSummary() {
final long backgroundTimeLessThanAMinute = 59999;
final long foregroundTimeZero = 0;
final long screenOnTimeZero = 0;
Bundle bundle = new Bundle();
bundle.putLong(
AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanAMinute);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeZero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeZero);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString())
.isEqualTo("Background: less than a min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeAMinuteBackgroundTwoMinWithSlotTime_hasCorrectSummary() {
final long backgroundTimeTwoMinutes = 120000;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeAMinute);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: 1 min\nBackground: 2 min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeAMinuteBackgroundLessThanAMinWithSlotTime_hasCorrectSummary() {
final long backgroundTimeLessThanAMinute = 59999;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
Bundle bundle = new Bundle();
bundle.putLong(
AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanAMinute);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeAMinute);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: 1 min\nBackground: less than a min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeAMinuteBackgroundZeroWithSlotTime_hasCorrectSummary() {
final long backgroundTimezero = 0;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimezero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeAMinute);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: 1 min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeLessThanAMinBackgroundTwoMinWithSlotTime_hasCorrectSummary() {
final long backgroundTimeTwoMinutes = 120000;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeLessThanAMinute = 59999;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeLessThanAMinute);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: less than a min\nBackground: 2 min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeLessAMinBackgroundLessAMinWithSlotTime_hasCorrectSummary() {
final long backgroundTimeLessThanAMinute = 59999;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeLessThanAMinute = 59999;
Bundle bundle = new Bundle();
bundle.putLong(
AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimeLessThanAMinute);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeLessThanAMinute);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: less than a min\nBackground: less than a min\n(12 am-2 am)");
}
@Test
public void initHeader_ScreenTimeLessThanAMinBackgroundZeroWithSlotTime_hasCorrectSummary() {
final long backgroundTimezero = 0;
final long foregroundTimeTwoMinutes = 120000;
final long screenOnTimeLessThanAMinute = 59999;
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, backgroundTimezero);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, foregroundTimeTwoMinutes);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, screenOnTimeLessThanAMinute);
bundle.putString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME, SLOT_TIME);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue().toString()).isEqualTo(
"Screen time: less than a min\n(12 am-2 am)");
}
@Test
public void initHeader_systemUidWithChartIsEnabled_notNullSummary() {
Bundle bundle = new Bundle();
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME, 240000);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME, 120000);
bundle.putLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME, 120000);
bundle.putInt(AdvancedPowerUsageDetail.EXTRA_UID, Process.SYSTEM_UID);
when(mFragment.getArguments()).thenReturn(bundle);
mFragment.initHeader();
ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
verify(mEntityHeaderController).setSummary(captor.capture());
assertThat(captor.getValue()).isNotNull();
}
@Test
public void startBatteryDetailPage_invalidToShowSummary_noFGBDData() {
AdvancedPowerUsageDetail.startBatteryDetailPage(mActivity, mFragment,
@@ -767,7 +366,7 @@ public class AdvancedPowerUsageDetailTest {
mFragment.onRadioButtonClicked(mOptimizePreference);
mFragment.onPause();
shadowMainLooper().idle();
TimeUnit.SECONDS.sleep(1);
verify(mMetricsFeatureProvider)
.action(
SettingsEnums.OPEN_APP_BATTERY_USAGE,
@@ -791,7 +390,7 @@ public class AdvancedPowerUsageDetailTest {
mFragment.onRadioButtonClicked(mOptimizePreference);
mFragment.onPause();
shadowMainLooper().idle();
TimeUnit.SECONDS.sleep(1);
verifyNoInteractions(mMetricsFeatureProvider);
}

248
tests/robotests/src/com/android/settings/fuelgauge/PowerUsageTimeControllerTest.java Normal file
View File

@@ -0,0 +1,248 @@
/*
* 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;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import android.content.Context;
import androidx.preference.Preference;
import androidx.preference.PreferenceCategory;
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;
@RunWith(RobolectricTestRunner.class)
public final class PowerUsageTimeControllerTest {
private static final String SLOT_TIME = "12 am-2 am";
private static final String KEY_SCREEN_ON_TIME_PREF = "battery_usage_screen_time";
private static final String KEY_BACKGROUND_TIME_PREF = "battery_usage_background_time";
private static final String TEST_ANOMALY_HINT_TEXT = "test_anomaly_hint_text";
private Context mContext;
private PowerUsageTimeController mPowerUsageTimeController;
@Mock
private PreferenceCategory mPowerUsageTimeCategory;
@Mock
private PowerUsageTimePreference mScreenTimePreference;
@Mock
private PowerUsageTimePreference mBackgroundTimePreference;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
mPowerUsageTimeController = new PowerUsageTimeController(mContext);
mPowerUsageTimeController.mPowerUsageTimeCategory = mPowerUsageTimeCategory;
mPowerUsageTimeController.mScreenTimePreference = mScreenTimePreference;
mPowerUsageTimeController.mBackgroundTimePreference = mBackgroundTimePreference;
doReturn(KEY_SCREEN_ON_TIME_PREF).when(mScreenTimePreference).getKey();
doReturn(KEY_BACKGROUND_TIME_PREF).when(mBackgroundTimePreference).getKey();
}
@Test
public void handleScreenTimeUpdated_noInfo_prefInvisible() {
mPowerUsageTimeController.handleScreenTimeUpdated(/*slotTime=*/ null,
/*screenOnTimeInMs=*/ 0, /*backgroundTimeInMs=*/ 0,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(false);
}
@Test
public void handleScreenTimeUpdated_onlySlotTime_prefInvisible() {
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
/*screenOnTimeInMs=*/ 0, /*backgroundTimeInMs=*/ 0,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(false);
}
@Test
public void handleScreenTimeUpdated_lackBackgroundTime_onlyScreenOnTime() {
final long screenOnTimeAMinute = 60000;
final long backgroundTimeZero = 0;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeAMinute, backgroundTimeZero,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyOnePreferenceInvisible(mBackgroundTimePreference);
verify(mScreenTimePreference).setTimeTitle("Screen time");
verify(mScreenTimePreference).setTimeSummary("1 min");
verify(mScreenTimePreference, never()).setAnomalyHint(anyString());
}
@Test
public void handleScreenTimeUpdated_lackScreenOnTime_onlyBackgroundTime() {
final long screenOnTimeZero = 0;
final long backgroundTimeTwoMinutes = 120000;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeZero, backgroundTimeTwoMinutes,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyOnePreferenceInvisible(mScreenTimePreference);
verify(mBackgroundTimePreference).setTimeTitle("Background time");
verify(mBackgroundTimePreference).setTimeSummary("2 min");
verify(mBackgroundTimePreference, never()).setAnomalyHint(anyString());
}
@Test
public void handleScreenTimeUpdated_categoryTitleWithSlotTime_expectedResult() {
final long screenOnTimeAMinute = 60000;
final long backgroundTimeTwoMinutes = 120000;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeAMinute, backgroundTimeTwoMinutes,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference).setTimeTitle("Screen time");
verify(mScreenTimePreference).setTimeSummary("1 min");
verify(mScreenTimePreference, never()).setAnomalyHint(anyString());
verify(mBackgroundTimePreference).setTimeTitle("Background time");
verify(mBackgroundTimePreference).setTimeSummary("2 min");
verify(mBackgroundTimePreference, never()).setAnomalyHint(anyString());
verify(mPowerUsageTimeCategory).setTitle("App usage for 12 am-2 am");
}
@Test
public void handleScreenTimeUpdated_categoryTitleWithoutSlotTime_expectedResult() {
final long backgroundTimeTwoMinutes = 120000;
final long screenOnTimeAMinute = 60000;
mPowerUsageTimeController.handleScreenTimeUpdated(/*slotTime=*/ null,
screenOnTimeAMinute, backgroundTimeTwoMinutes,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(true);
verify(mPowerUsageTimeCategory).setTitle("App usage since last full charge");
}
@Test
public void handleScreenTimeUpdated_BackgroundLessThanAMinWithSlotTime_expectedResult() {
final long screenOnTimeAMinute = 60000;
final long backgroundTimeLessThanAMinute = 59999;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeAMinute, backgroundTimeLessThanAMinute,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference).setTimeSummary("1 min");
verify(mBackgroundTimePreference).setTimeSummary("Less than a min");
}
@Test
public void handleScreenTimeUpdated_ScreenTimeLessThanAMin_expectedResult() {
final long screenOnTimeLessThanAMinute = 59999;
final long backgroundTimeTwoMinutes = 120000;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeLessThanAMinute, backgroundTimeTwoMinutes,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference).setTimeSummary("Less than a min");
verify(mBackgroundTimePreference).setTimeSummary("2 min");
}
@Test
public void handleScreenTimeUpdated_bothLessThanAMin_expectedResult() {
final long screenOnTimeLessThanAMinute = 59999;
final long backgroundTimeLessThanAMinute = 59999;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeLessThanAMinute, backgroundTimeLessThanAMinute,
/*anomalyHintPrefKey=*/ null, /*anomalyHintText=*/ null);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference).setTimeSummary("Less than a min");
verify(mBackgroundTimePreference).setTimeSummary("Less than a min");
}
@Test
public void handleScreenTimeUpdated_anomalyOfScreenOnTime_expectedResult() {
final long screenOnTimeAMinute = 60000;
final long backgroundTimeTwoMinutes = 120000;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeAMinute, backgroundTimeTwoMinutes,
KEY_SCREEN_ON_TIME_PREF, TEST_ANOMALY_HINT_TEXT);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference).setAnomalyHint(TEST_ANOMALY_HINT_TEXT);
verify(mBackgroundTimePreference, never()).setAnomalyHint(anyString());
}
@Test
public void handleScreenTimeUpdated_anomalyOfBackgroundTime_expectedResult() {
final long screenOnTimeAMinute = 60000;
final long backgroundTimeTwoMinutes = 120000;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeAMinute, backgroundTimeTwoMinutes,
KEY_BACKGROUND_TIME_PREF, TEST_ANOMALY_HINT_TEXT);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference, never()).setAnomalyHint(anyString());
verify(mBackgroundTimePreference).setAnomalyHint(TEST_ANOMALY_HINT_TEXT);
}
@Test
public void handleScreenTimeUpdated_anomalyOfScreenOnTimeWithoutTimeInfo_expectedResult() {
final long screenOnTimeZero = 0;
final long backgroundTimeTwoMinutes = 120000;
mPowerUsageTimeController.handleScreenTimeUpdated(SLOT_TIME,
screenOnTimeZero, backgroundTimeTwoMinutes,
KEY_SCREEN_ON_TIME_PREF, TEST_ANOMALY_HINT_TEXT);
verifyAllPreferencesVisible(true);
verify(mScreenTimePreference).setTimeSummary("Less than a min");
verify(mScreenTimePreference).setAnomalyHint(TEST_ANOMALY_HINT_TEXT);
verify(mBackgroundTimePreference, never()).setAnomalyHint(anyString());
}
private void verifySetPrefToVisible(Preference pref, boolean isVisible) {
verify(pref, isVisible ? times(1) : never()).setVisible(true);
}
private void verifyAllPreferencesVisible(boolean isVisible) {
verifySetPrefToVisible(mScreenTimePreference, isVisible);
verifySetPrefToVisible(mBackgroundTimePreference, isVisible);
verifySetPrefToVisible(mPowerUsageTimeCategory, isVisible);
}
private void verifyOnePreferenceInvisible(Preference pref) {
verifySetPrefToVisible(mScreenTimePreference, mScreenTimePreference != pref);
verifySetPrefToVisible(mBackgroundTimePreference, mBackgroundTimePreference != pref);
verifySetPrefToVisible(mPowerUsageTimeCategory, mPowerUsageTimeCategory != pref);
}
}