From a8fa5aad69551156b255bdb470d420a253d82c96 Mon Sep 17 00:00:00 2001 From: mxyyiyi Date: Fri, 13 Oct 2023 12:40:14 +0800 Subject: [PATCH] Fix broken RoboTests in "com.android.settings.fuelgauge.*" Bug: 305125530 Test: make RunSettingsRoboTests ROBOTEST_FILTER="com.android.settings.fuelgauge.*" Change-Id: Idaf2a5da4aef3a2fe317fc1f5a24ba9ba457cadd --- .../AdvancedPowerUsageDetailTest.java | 409 +----------------- .../PowerUsageTimeControllerTest.java | 248 +++++++++++ 2 files changed, 252 insertions(+), 405 deletions(-) create mode 100644 tests/robotests/src/com/android/settings/fuelgauge/PowerUsageTimeControllerTest.java diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java index 58274981603..9131051ccd1 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java @@ -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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageTimeControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageTimeControllerTest.java new file mode 100644 index 00000000000..2449040e142 --- /dev/null +++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageTimeControllerTest.java @@ -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); + } +}